shipit-engine 0.38.0 → 0.40.0

data/app/models/shipit/stack.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'fileutils'
 
 module Shipit
@@ -24,7 +25,7 @@ module Shipit
     end
 
     ENVIRONMENT_MAX_SIZE = 50
-    REQUIRED_HOOKS = %i(push status).freeze
+    REQUIRED_HOOKS = %i[push status].freeze
 
     has_many :commits, dependent: :destroy
     has_many :merge_requests, dependent: :destroy
@@ -32,12 +33,13 @@ module Shipit
     has_many :deploys
     has_many :rollbacks
     has_many :deploys_and_rollbacks,
-      -> { where(type: %w(Shipit::Deploy Shipit::Rollback)) },
-      class_name: 'Task',
-      inverse_of: :stack
+             -> { where(type: %w[Shipit::Deploy Shipit::Rollback]) },
+             class_name: 'Task',
+             inverse_of: :stack
     has_many :github_hooks, dependent: :destroy, class_name: 'Shipit::GithubHook::Repo'
     has_many :hooks, dependent: :destroy
     has_many :api_clients, dependent: :destroy
+    has_one :continuous_delivery_schedule, dependent: :destroy
     belongs_to :lock_author, class_name: :User, optional: true
     belongs_to :repository
     validates_associated :repository
@@ -56,7 +58,7 @@ module Shipit
         'GITHUB_REPO_OWNER' => repository.owner,
         'GITHUB_REPO_NAME' => repository.name,
         'DEPLOY_URL' => deploy_url,
-        'BRANCH' => branch,
+        'BRANCH' => branch
       }
     end
 
@@ -86,22 +88,22 @@ module Shipit
     after_commit :sync_github_if_necessary, on: :update
 
     def sync_github_if_necessary
-      if (archived_since_previously_changed? && archived_since.nil?) || branch_previously_changed?
-        sync_github
-      end
+      return unless (archived_since_previously_changed? && archived_since.nil?) || branch_previously_changed?
+
+      sync_github
     end
 
     validates :repository, uniqueness: {
-      scope: %i(environment), case_sensitive: false,
-      message: 'cannot be used more than once with this environment. Check archived stacks.',
+      scope: %i[environment], case_sensitive: false,
+      message: 'cannot be used more than once with this environment. Check archived stacks.'
     }
-    validates :environment, format: { with: /\A[a-z0-9\-_\:]+\z/ }, length: { maximum: ENVIRONMENT_MAX_SIZE }
-    validates :deploy_url, format: { with: URI.regexp(%w(http https ssh)) }, allow_blank: true
+    validates :environment, format: { with: /\A[a-z0-9\-_:]+\z/ }, length: { maximum: ENVIRONMENT_MAX_SIZE }
+    validates :deploy_url, format: { with: URI::DEFAULT_PARSER.make_regexp(%w[http https ssh]) }, allow_blank: true
     validates :branch, presence: true
 
     validates :lock_reason, length: { maximum: 4096 }
 
-    serialize :cached_deploy_spec, DeploySpec
+    serialize :cached_deploy_spec, coder: DeploySpec
     delegate(
       :provisioning_handler_name,
       :find_task_definition,
@@ -130,7 +132,7 @@ module Shipit
 
     def trigger_task(definition_id, user, env: nil, force: false)
       definition = find_task_definition(definition_id)
-      env = env&.to_h || {}
+      env = env.to_h
 
       definition.variables_with_defaults.each do |variable|
         env[variable.name] ||= variable.default
@@ -139,27 +141,27 @@ module Shipit
       commit = last_deployed_commit.presence || commits.first
       task = tasks.create(
         user_id: user.id,
-        definition: definition,
+        definition:,
         until_commit_id: commit.id,
         since_commit_id: commit.id,
         env: definition.filter_envs(env),
         allow_concurrency: definition.allow_concurrency? || force,
-        ignored_safeties: force,
+        ignored_safeties: force
       )
       task.enqueue
       task
     end
 
-    def build_deploy(until_commit, user, env: nil, force: false)
+    def build_deploy(until_commit, user, env: nil, force: false, allow_concurrency: force)
       since_commit = last_deployed_commit.presence || commits.first
       deploys.build(
         user_id: user.id,
-        until_commit: until_commit,
-        since_commit: since_commit,
-        env: filter_deploy_envs(env&.to_h || {}),
-        allow_concurrency: force,
+        until_commit:,
+        since_commit:,
+        env: filter_deploy_envs(env.to_h),
+        allow_concurrency:,
         ignored_safeties: force || !until_commit.deployable?,
-        max_retries: retries_on_deploy,
+        max_retries: retries_on_deploy
       )
     end
 
@@ -226,22 +228,25 @@ module Shipit
 
     def next_commit_to_deploy
       commits_to_deploy = commits.order(id: :asc).newer_than(last_deployed_commit).reachable.preload(:statuses)
-      commits_to_deploy = commits_to_deploy.limit(maximum_commits_per_deploy) if maximum_commits_per_deploy
-      commits_to_deploy.to_a.reverse.find(&:deployable?)
+      if maximum_commits_per_deploy
+        commits_with_max_applied = commits_to_deploy.limit(maximum_commits_per_deploy)
+        deployable_commits(commits_with_max_applied) || deployable_commits(commits_to_deploy)
+      else
+        deployable_commits(commits_to_deploy)
+      end
     end
 
     def deployed_too_recently?
-      if task = last_active_task
-        return true if task.validating?
+      return unless task = last_active_task
+      return true if task.validating?
 
-        task.ended_at? && (task.ended_at + pause_between_deploys).future?
-      end
+      task.ended_at? && (task.ended_at + pause_between_deploys).future?
     end
 
     def async_refresh_deployed_revision
       async_refresh_deployed_revision!
-    rescue => error
-      logger.warn("Failed to dispatch FetchDeployedRevisionJob: [#{error.class.name}] #{error.message}")
+    rescue StandardError => e
+      logger.warn("Failed to dispatch FetchDeployedRevisionJob: [#{e.class.name}] #{e.message}")
     end
 
     def async_refresh_deployed_revision!
@@ -263,7 +268,7 @@ module Shipit
         deploys.create!(
           until_commit: actual_deployed_commit,
           since_commit: last_deployed_commit.presence || commits.first,
-          status: 'success',
+          status: 'success'
         )
       end
     end
@@ -274,8 +279,9 @@ module Shipit
 
     def merge_status(backlog_leniency_factor: 2.0)
       return 'locked' if locked?
-      return 'failure' if %w(failure error).freeze.include?(branch_status)
-      return 'backlogged' if backlogged?(backlog_leniency_factor: backlog_leniency_factor)
+      return 'failure' if %w[failure error].freeze.include?(branch_status)
+      return 'backlogged' if backlogged?(backlog_leniency_factor:)
+
       'success'
     end
 
@@ -286,13 +292,14 @@ module Shipit
     def branch_status
       undeployed_commits.each do |commit|
         state = commit.status.simple_state
-        return state unless %w(pending unknown missing).freeze.include?(state)
+        return state unless %w[pending unknown missing].freeze.include?(state)
       end
       'pending'
     end
 
     def status
       return :deploying if active_task?
+
       :default
     end
 
@@ -309,8 +316,8 @@ module Shipit
         next if commits_to_lock.empty?
 
         affected_rows += commits
-          .where(id: commits_to_lock.map(&:id).uniq)
-          .lock_all(revert.author)
+                         .where(id: commits_to_lock.map(&:id).uniq)
+                         .lock_all(revert.author)
       end
 
       touch if affected_rows > 1
@@ -392,13 +399,14 @@ module Shipit
     end
 
     def acquire_git_cache_lock(timeout: 15, &block)
-      @git_cache_lock ||= Flock.new(git_path.to_s + '.lock')
-      @git_cache_lock.lock(timeout: timeout, &block)
+      @git_cache_lock ||= Flock.new("#{git_path}.lock")
+      @git_cache_lock.lock(timeout:, &block)
     end
 
     def clear_git_cache!
       tmp_path = "#{git_path}-#{SecureRandom.hex}"
       return unless git_path.exist?
+
       acquire_git_cache_lock do
         git_path.rename(tmp_path)
       end
@@ -438,9 +446,7 @@ module Shipit
 
     def refresh_repository!
       resource = github_api.repo(github_repo_name)
-      if resource.try(:message) == 'Moved Permanently'
-        resource = github_api.get(resource.url)
-      end
+      resource = github_api.get(resource.url) if resource.try(:message) == 'Moved Permanently'
       repository.update!(owner: resource.owner.login, name: resource.name)
     end
 
@@ -450,6 +456,7 @@ module Shipit
 
     def active_task
       return @active_task if defined?(@active_task)
+
       @active_task ||= tasks.current
     end
 
@@ -496,7 +503,7 @@ module Shipit
       env = stack.cached_deploy_spec.default_deploy_env
       current_user = Shipit::CommandLineUser.new
 
-      stack.trigger_deploy(until_commit, current_user, env: env, force: true, run_now: true)
+      stack.trigger_deploy(until_commit, current_user, env:, force: true, run_now: true)
     end
 
     def self.from_param!(param)
@@ -505,16 +512,16 @@ module Shipit
         .where(
           repositories: {
             owner: repo_owner.downcase,
-            name: repo_name.downcase,
+            name: repo_name.downcase
           },
-          environment: environment,
+          environment:
         ).first!
     end
 
     delegate :plugins, :task_definitions, :hidden_statuses, :required_statuses, :soft_failing_statuses,
-      :blocking_statuses, :deploy_variables, :filter_task_envs, :filter_deploy_envs,
-      :maximum_commits_per_deploy, :pause_between_deploys, :retries_on_deploy, :retries_on_rollback,
-      to: :cached_deploy_spec
+             :blocking_statuses, :deploy_variables, :filter_task_envs, :filter_deploy_envs,
+             :maximum_commits_per_deploy, :pause_between_deploys, :retries_on_deploy, :retries_on_rollback,
+             to: :cached_deploy_spec
 
     def monitoring?
       monitoring.present?
@@ -539,16 +546,16 @@ module Shipit
     end
 
     def update_latest_deployed_ref
-      if Shipit.update_latest_deployed_ref
-        UpdateGithubLastDeployedRefJob.perform_later(self)
-      end
+      return unless Shipit.update_latest_deployed_ref
+
+      UpdateGithubLastDeployedRefJob.perform_later(self)
     end
 
     def broadcast_update
       Pubsubstub.publish(
         "stack.#{id}",
-        { id: id, updated_at: updated_at }.to_json,
-        name: 'update',
+        { id:, updated_at: }.to_json,
+        name: 'update'
       )
     end
 
@@ -620,14 +627,18 @@ module Shipit
       return unless previous_changes.include?('lock_reason')
 
       lock_details = if previous_changes['lock_reason'].last.blank?
-        { from: previous_changes['locked_since'].first, until: Time.zone.now }
-      end
+                       { from: previous_changes['locked_since'].first, until: Time.zone.now }
+                     end
 
-      Hook.emit(:lock, self, locked: locked?, lock_details: lock_details, stack: self)
+      Hook.emit(:lock, self, locked: locked?, lock_details:, stack: self)
     end
 
     private
 
+    def deployable_commits(commits)
+      commits.to_a.reverse.find(&:deployable?)
+    end
+
     def clear_cache
       remove_instance_variable(:@active_task) if defined?(@active_task)
     end
@@ -654,9 +665,9 @@ module Shipit
     end
 
     def schedule_merges_if_necessary
-      if lock_reason_previously_changed? && lock_reason.blank?
-        schedule_merges
-      end
+      return unless lock_reason_previously_changed? && lock_reason.blank?
+
+      schedule_merges
     end
 
     def emit_added_hooks
@@ -664,7 +675,7 @@ module Shipit
     end
 
     def emit_updated_hooks
-      changed = !(previous_changes.keys - %w(updated_at)).empty?
+      changed = !(previous_changes.keys - %w[updated_at]).empty?
       Hook.emit(:stack, self, action: :updated, stack: self) if changed
     end
 
@@ -673,7 +684,7 @@ module Shipit
     end
 
     def emit_merge_status_hooks
-      Hook.emit(:merge_status, self, merge_status: merge_status, stack: self)
+      Hook.emit(:merge_status, self, merge_status:, stack: self)
     end
 
     def ci_enabled_cache_key

data/app/models/shipit/status/common.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Shipit
   class Status
     module Common

data/app/models/shipit/status/group.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Shipit
   class Status
     class Group
@@ -31,7 +32,7 @@ module Shipit
       end
 
       delegate :pending?, :success?, :error?, :failure?, :unknown?, :missing?, :state, :simple_state,
-        to: :significant_status
+               to: :significant_status
       delegate :each, :size, :map, to: :statuses
       delegate :required_statuses, to: :commit
 
@@ -43,8 +44,7 @@ module Shipit
         "#{success_count} / #{statuses.count} checks OK"
       end
 
-      def target_url
-      end
+      def target_url; end
 
       def to_partial_path
         'statuses/group'
@@ -75,8 +75,10 @@ module Shipit
       def select_significant_status(statuses)
         statuses = reject_allowed_to_fail(statuses)
         return Status::Unknown.new(commit) if statuses.empty?
+
         non_success_statuses = statuses.reject(&:success?)
         return statuses.first if non_success_statuses.empty?
+
         non_success_statuses.reject(&:pending?).first || non_success_statuses.first || Status::Unknown.new(commit)
       end
 

data/app/models/shipit/status/missing.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Shipit
   class Status
     class Missing
@@ -24,7 +25,7 @@ module Shipit
       end
 
       def description
-        I18n.t('missing_status.description', context: context)
+        I18n.t('missing_status.description', context:)
       end
 
       def to_partial_path

data/app/models/shipit/status/unknown.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Shipit
   class Status
     class Unknown

data/app/models/shipit/status.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
+
 module Shipit
   class Status < Record
     include Common
     include DeferredTouch
 
-    STATES = %w(pending success failure error).freeze
-    enum state: STATES.zip(STATES).to_h
+    STATES = %w[pending success failure error].freeze
+    enum :state, STATES.zip(STATES).to_h
 
     belongs_to :stack, required: true
     belongs_to :commit, required: true
@@ -22,12 +23,12 @@ module Shipit
     class << self
       def replicate_from_github!(stack_id, github_status)
         find_or_create_by!(
-          stack_id: stack_id,
+          stack_id:,
           state: github_status.state,
           description: github_status.description,
           target_url: github_status.target_url,
           context: github_status.context,
-          created_at: github_status.created_at,
+          created_at: github_status.created_at
         )
       end
     end

data/app/models/shipit/task.rb

@@ -1,17 +1,22 @@
 # frozen_string_literal: true
+
 module Shipit
   class Task < Record
     include DeferredTouch
 
-    ConcurrentTaskRunning = Class.new(StandardError)
+    class ConcurrentTaskRunning < StandardError
+      def message
+        "A task is already running."
+      end
+    end
 
     PRESENCE_CHECK_TIMEOUT = 30
-    ACTIVE_STATUSES = %w(pending running aborting).freeze
-    COMPLETED_STATUSES = %w(success flapping faulty validating).freeze
-    UNSUCCESSFUL_STATUSES = %w(error failed aborted flapping timedout faulty).freeze
+    ACTIVE_STATUSES = %w[pending running aborting].freeze
+    COMPLETED_STATUSES = %w[success flapping faulty validating].freeze
+    UNSUCCESSFUL_STATUSES = %w[error failed aborted flapping timedout faulty].freeze
     OUTPUT_SIZE_LIMIT = 16.megabytes # A MySQL mediumblob
     HUMAN_READABLE_OUTPUT_LIMIT = ActionController::Base.helpers.number_to_human_size(OUTPUT_SIZE_LIMIT)
-    OUTPUT_TRUNCATED_MESSAGE = "Output exceeded the limit of #{HUMAN_READABLE_OUTPUT_LIMIT} and was truncated\n"
+    OUTPUT_TRUNCATED_MESSAGE = "Output exceeded the limit of #{HUMAN_READABLE_OUTPUT_LIMIT} and was truncated\n".freeze
 
     attr_accessor :pid
 
@@ -31,6 +36,7 @@ module Shipit
       class << self
         def dump(hash)
           raise TypeError, "Task#env should be a Hash[String => String]" unless hash.is_a?(Hash)
+
           hash = hash.to_h.stringify_keys
           hash.transform_values! do |value|
             case value
@@ -45,7 +51,7 @@ module Shipit
         end
 
         def load(hash)
-          hash&.to_h || {} # cast back to a real hash
+          hash.to_h # cast back to a real hash
         end
 
         def new
@@ -54,8 +60,8 @@ module Shipit
       end
     end
 
-    serialize :definition, TaskDefinition
-    serialize :env, Shipit.serialized_column(:env, coder: EnvHash)
+    serialize :definition, coder: TaskDefinition
+    serialize :env, coder: Shipit.serialized_column(:env, coder: EnvHash)
 
     scope :success, -> { where(status: 'success') }
     scope :completed, -> { where(status: COMPLETED_STATUSES) }
@@ -100,11 +106,11 @@ module Shipit
         task.ended_at ||= Time.now.utc
       end
 
-      after_transition any => %i(success failed error timedout) do |task|
+      after_transition any => %i[success failed error timedout] do |task|
         task.async_refresh_deployed_revision
       end
 
-      after_transition any => %i(aborted success failed error timedout) do |task|
+      after_transition any => %i[aborted success failed error timedout] do |task|
         task.schedule_rollup_chunks
       end
 
@@ -116,7 +122,7 @@ module Shipit
         task.async_update_estimated_deploy_duration
       end
 
-      after_transition any => %i(failed error timedout) do |task|
+      after_transition any => %i[failed error timedout] do |task|
         task.retry_if_necessary
       end
 
@@ -125,19 +131,19 @@ module Shipit
       end
 
       event :failure do
-        transition %i(running flapping) => :failed
+        transition %i[running flapping] => :failed
       end
 
       event :complete do
-        transition %i(running flapping validating faulty) => :success
+        transition %i[running flapping validating faulty] => :success
       end
 
       event :enter_validation do
-        transition %i(running flapping) => :validating
+        transition %i[running flapping] => :validating
       end
 
       event :mark_faulty do
-        transition %i(validating success) => :faulty
+        transition %i[validating success] => :faulty
       end
 
       event :error do
@@ -149,7 +155,7 @@ module Shipit
       end
 
       event :aborting do
-        transition all - %i(aborted) => :aborting
+        transition all - %i[aborted] => :aborting
       end
 
       event :aborted do
@@ -157,7 +163,7 @@ module Shipit
       end
 
       event :flap do
-        transition %i(failed error timedout success) => :flapping
+        transition %i[failed error timedout success] => :flapping
       end
 
       state :pending
@@ -202,7 +208,7 @@ module Shipit
     end
 
     delegate :acquire_git_cache_lock, :async_refresh_deployed_revision, :async_update_estimated_deploy_duration,
-      to: :stack
+             to: :stack
 
     delegate :checklist, to: :definition
 
@@ -215,16 +221,18 @@ module Shipit
     end
 
     def spec
-      @spec ||= DeploySpec::FileSystem.new(working_directory, stack.environment)
+      @spec ||= DeploySpec::FileSystem.new(working_directory, stack)
     end
 
     def enqueue
       raise "only persisted jobs can be enqueued" unless persisted?
+
       PerformTaskJob.perform_later(self)
     end
 
     def run_now!
       raise "only persisted jobs can be run" unless persisted?
+
       PerformTaskJob.perform_now(self)
     end
 
@@ -346,10 +354,10 @@ module Shipit
       end
     end
 
-    def abort!(rollback_once_aborted: false, rollback_once_aborted_to: nil, aborted_by:)
+    def abort!(aborted_by:, rollback_once_aborted: false, rollback_once_aborted_to: nil)
       update!(
-        rollback_once_aborted: rollback_once_aborted,
-        rollback_once_aborted_to: rollback_once_aborted_to,
+        rollback_once_aborted:,
+        rollback_once_aborted_to:,
         aborted_by_id: aborted_by.id
       )
 
@@ -379,12 +387,13 @@ module Shipit
 
     def emit_hooks_if_status_changed
       return unless @status_changed
+
       @status_changed = nil
       emit_hooks
     end
 
     def emit_hooks
-      Hook.emit(hook_event, stack, hook_event => self, status: status, stack: stack)
+      Hook.emit(hook_event, stack, hook_event => self, status:, stack:)
     end
 
     def hook_event
@@ -423,13 +432,13 @@ module Shipit
       5.minutes.ago
     end
 
-    ZOMBIE_STATES = %w(running aborting).freeze
+    ZOMBIE_STATES = %w[running aborting].freeze
     private_constant :ZOMBIE_STATES
     def self.zombies
       where(status: ZOMBIE_STATES)
         .where(
           "created_at <= :recently",
-          recently: recently_created_at,
+          recently: recently_created_at
         )
         .reject(&:alive?)
     end
@@ -437,13 +446,13 @@ module Shipit
     def retry_if_necessary
       return unless retries_configured? && !stack.reload.locked?
 
-      if retry_attempt < max_retries
-        retry_task = duplicate_task
-        retry_task.retry_attempt = duplicate_task.retry_attempt + 1
-        retry_task.save!
+      return unless retry_attempt < max_retries
 
-        retry_task.enqueue
-      end
+      retry_task = duplicate_task
+      retry_task.retry_attempt = duplicate_task.retry_attempt + 1
+      retry_task.save!
+
+      retry_task.enqueue
     end
 
     def retries_configured?

data/app/models/shipit/task_definition.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Shipit
   class TaskDefinition
     NotFound = Class.new(StandardError)
@@ -6,18 +7,20 @@ module Shipit
     class << self
       def load(payload)
         return if payload.blank?
+
         json = JSON.parse(payload)
         new(json.delete('id'), json)
       end
 
       def dump(definition)
         return if definition.blank?
+
         JSON.dump(definition.as_json)
       end
     end
 
     attr_reader :id, :action, :description, :steps, :checklist, :variables
-    alias_method :to_param, :id
+    alias to_param id
 
     def initialize(id, config)
       @id = id
@@ -46,14 +49,14 @@ module Shipit
 
     def as_json
       {
-        id: id,
-        action: action,
+        id:,
+        action:,
         title: @title,
-        description: description,
-        steps: steps,
+        description:,
+        steps:,
         variables: variables.map(&:to_h),
-        checklist: checklist,
-        allow_concurrency: allow_concurrency?,
+        checklist:,
+        allow_concurrency: allow_concurrency?
       }
     end