shipit-engine 0.11.0 → 0.12.0

data/app/controllers/shipit/shipit_controller.rb

@@ -42,7 +42,7 @@ module Shipit
         teams = Shipit.github_teams
         unless teams.empty? || current_user.teams.where(id: teams).exists?
           team_list = teams.map(&:handle).to_sentence(two_words_connector: ' or ', last_word_connector: ', or ')
-          render text: "You must be a member of #{team_list} to access this application.", status: :forbidden
+          render plain: "You must be a member of #{team_list} to access this application.", status: :forbidden
         end
       else
         redirect_to Shipit::Engine.routes.url_helpers.github_authentication_path(origin: request.original_url)

data/app/controllers/shipit/stacks_controller.rb

@@ -45,7 +45,7 @@ module Shipit
       RefreshStatusesJob.perform_later(stack_id: @stack.id)
       GithubSyncJob.perform_later(stack_id: @stack.id)
       flash[:success] = 'Refresh scheduled'
-      redirect_to request.referer ? :back : stack_path(@stack)
+      redirect_to request.referer.presence || stack_path(@stack)
     end
 
     def update
@@ -53,6 +53,14 @@ module Shipit
       unless @stack.update(update_params)
         options = {flash: {warning: @stack.errors.full_messages.to_sentence}}
       end
+
+      reason = params[:stack][:lock_reason]
+      if reason.present?
+        @stack.lock(reason, current_user)
+      elsif @stack.locked?
+        @stack.unlock
+      end
+
       redirect_to(params[:return_to].presence || stack_settings_path(@stack), options)
     end
 
@@ -77,10 +85,8 @@ module Shipit
     end
 
     def update_params
-      params.require(:stack).permit(:deploy_url, :lock_reason, :environment,
-                                    :continuous_deployment, :ignore_ci).tap do |params|
-        params[:lock_author_id] = params[:lock_reason].present? ? current_user.id : nil
-      end
+      params.require(:stack).permit(:deploy_url, :environment,
+                                    :continuous_deployment, :ignore_ci)
     end
   end
 end

data/app/controllers/shipit/status_controller.rb

@@ -1,7 +1,7 @@
 module Shipit
   class StatusController < ActionController::Base
     def version
-      render text: Shipit.revision
+      render plain: Shipit.revision
     end
   end
 end

data/app/controllers/shipit/webhooks_controller.rb

@@ -9,17 +9,27 @@ module Shipit
 
       if branch == stack.branch
         GithubSyncJob.perform_later(stack_id: stack.id)
-        GitMirrorUpdateJob.perform_later(stack)
       end
 
       head :ok
     end
 
+    params do
+      requires :sha, String
+      requires :state, String
+      accepts :description, String
+      accepts :target_url, String
+      accepts :context, String
+      accepts :created_at, String
+
+      accepts :branches, Array do
+        requires :name, String
+      end
+    end
     def state
-      branches = params[:branches] || []
-      if branches.find { |branch| branch[:name] == stack.branch }
-        commit = stack.commits.find_by_sha!(params[:sha])
-        commit.add_status(params.permit(:state, :description, :target_url, :context, :created_at))
+      if params.branches.map(&:name).include?(stack.branch)
+        commit = stack.commits.find_by_sha!(params.sha)
+        commit.create_status_from_github!(params)
       end
       head :ok
     end

data/app/helpers/shipit/deploys_helper.rb

@@ -12,7 +12,7 @@ module Shipit
 
     def render_checks(commit)
       return unless commit.stack.checks?
-      render 'shipit/deploys/checks', commit: commit
+      render 'shipit/commit_checks/checks', commit: commit
     end
 
     def render_monitoring_panel(panel_spec)

data/app/helpers/shipit/shipit_helper.rb

@@ -36,6 +36,8 @@ module Shipit
         If you haven't created an application on GitHub yet, you can do so in the
         #{link_to 'Settings', Shipit.github_url('/settings/applications/new'), target: '_blank'}
         section of your profile. You can also create applications for organizations.
+        When setting up your application in Github, set the Homepage URL to your domain
+        and the Authorization callback URL to '<yourdomain>/github/auth/github/callback'.
       MESSAGE
     end
 

data/app/jobs/shipit/perform_commit_checks_job.rb

@@ -1,5 +1,7 @@
 module Shipit
   class PerformCommitChecksJob < BackgroundJob
+    include BackgroundJob::Unique
+
     def perform(commit:)
       commit.checks.run
     end

data/app/jobs/shipit/perform_task_job.rb

@@ -53,24 +53,26 @@ module Shipit
 
     def perform_task
       Bundler.with_clean_env do
-        capture_all @commands.install_dependencies
-        capture_all @commands.perform
+        capture_all! @commands.install_dependencies
+        capture_all! @commands.perform
       end
     end
 
     def checkout_repository
       @task.acquire_git_cache_lock do
-        capture @commands.fetch
-        capture @commands.clone
+        unless capture @commands.fetched?(@task.until_commit)
+          capture! @commands.fetch
+        end
       end
-      capture @commands.checkout(@task.until_commit)
+      capture! @commands.clone
+      capture! @commands.checkout(@task.until_commit)
     end
 
-    def capture_all(commands)
-      commands.map { |c| capture(c) }
+    def capture_all!(commands)
+      commands.map { |c| capture!(c) }
     end
 
-    def capture(command)
+    def capture!(command)
       command.start do
         @task.ping
         check_for_abort
@@ -81,6 +83,14 @@ module Shipit
         @task.write(line)
       end
       @task.write("\n")
+      command.success?
+    end
+
+    def capture(command)
+      capture!(command)
+      command.success?
+    rescue Command::Error
+      false
     end
   end
 end

data/app/models/shipit/commit.rb

@@ -82,22 +82,14 @@ module Shipit
     def refresh_statuses!
       github_statuses = stack.handle_github_redirections { Shipit.github_api.statuses(github_repo_name, sha) }
       github_statuses.each do |status|
-        statuses.replicate_from_github!(status)
+        create_status_from_github!(status)
       end
     end
 
-    def add_status(status_attributes)
-      previous_status = significant_status
-      statuses.create!(status_attributes)
-      reload # to get the statuses into the right order (since sorted :desc)
-      new_status = significant_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?
-        Hook.emit(:deployable_status, stack, payload.merge(deployable_status: new_status))
+    def create_status_from_github!(github_status)
+      add_status do
+        statuses.replicate_from_github!(github_status)
       end
-      new_status
     end
 
     def checks
@@ -192,8 +184,26 @@ module Shipit
       stack.last_deployed_commit.id >= id
     end
 
+    def deploy_failed?
+      stack.deploys.unsuccessful.where(until_commit_id: id).any?
+    end
+
     private
 
+    def add_status
+      previous_status = significant_status
+      yield
+      reload # to get the statuses into the right order (since sorted :desc)
+      new_status = significant_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))
+      end
+      new_status
+    end
+
     def missing_statuses
       stack.required_statuses - last_statuses.map(&:context)
     end

data/app/models/shipit/commit_checks.rb

@@ -1,5 +1,5 @@
 module Shipit
-  class CommitChecks
+  class CommitChecks < EphemeralCommitChecks
     OUTPUT_TTL = 10.minutes.to_i
     FINAL_STATUSES = %w(failed error success).freeze
 
@@ -7,30 +7,28 @@ module Shipit
       @commit = commit
     end
 
-    def run
-      self.status = 'running'
-      commands = StackCommands.new(stack)
-      commands.with_temporary_working_directory(commit: commit) do |directory|
-        deploy_spec = DeploySpec::FileSystem.new(directory, stack.environment)
-        Bundler.with_clean_env do
-          capture_all(build_commands(deploy_spec.dependencies_steps, chdir: directory))
-          capture_all(build_commands(deploy_spec.review_checks, chdir: directory))
-        end
-      end
-    rescue Command::Error
-      self.status = 'failed'
-    rescue
-      self.status = 'error'
-      raise
-    else
-      self.status = 'success'
+    def synchronize(&block)
+      @lock ||= Redis::Lock.new('lock', redis, expiration: 1, timeout: 2)
+      @lock.lock(&block)
     end
 
     def schedule
-      if redis.set('output', '', ex: OUTPUT_TTL, nx: true)
-        self.status = 'scheduled'
-        PerformCommitChecksJob.perform_later(commit: commit)
+      return false if redis.get('status').present?
+      synchronize do
+        return false if redis.get('status').present?
+
+        initialize_redis_state
+      end
+      PerformCommitChecksJob.perform_later(commit: commit)
+      true
+    end
+
+    def initialize_redis_state
+      redis.pipelined do
+        redis.set('output', '', ex: OUTPUT_TTL)
+        redis.set('status', 'scheduled', ex: OUTPUT_TTL)
       end
+      @status = 'scheduled'
     end
 
     def status
@@ -38,14 +36,10 @@ module Shipit
     end
 
     def status=(status)
-      redis.set('status', status, ex: OUTPUT_TTL)
+      redis.set('status', status)
       @status = status
     end
 
-    def finished?
-      FINAL_STATUSES.include?(status)
-    end
-
     def output(since: 0)
       redis.getrange('output', since, -1)
     end
@@ -56,35 +50,8 @@ module Shipit
 
     private
 
-    def build_commands(commands, chdir:)
-      commands.map { |c| Command.new(c, env: Shipit.env, chdir: chdir) }
-    end
-
-    def capture_all(commands)
-      commands.map { |c| capture(c) }
-    end
-
-    def capture(command)
-      command.start
-      write("$ #{command}\n")
-      command.stream! do |line|
-        write(line)
-      end
-    rescue Command::Error => error
-      write(error.message)
-      raise
-    ensure
-      write("\n")
-    end
-
-    attr_reader :commit
-
     def redis
       @redis ||= Shipit.redis("commit:#{commit.id}:checks")
     end
-
-    def stack
-      @stack ||= commit.stack
-    end
   end
 end

data/app/models/shipit/deploy.rb

@@ -42,7 +42,7 @@ module Shipit
         parent_id: id,
         since_commit: stack.last_deployed_commit,
         until_commit: until_commit,
-        env: env || {},
+        env: env.try!(:to_h) || {},
       )
     end
 

data/app/models/shipit/ephemeral_commit_checks.rb

@@ -0,0 +1,76 @@
+module Shipit
+  class EphemeralCommitChecks
+    FINAL_STATUSES = %w(failed error success).freeze
+
+    def initialize(commit)
+      @commit = commit
+    end
+
+    attr_accessor :status
+    attr_reader :output
+
+    def run
+      self.status = 'running'
+      commands = StackCommands.new(stack)
+      commands.with_temporary_working_directory(commit: commit) do |directory|
+        deploy_spec = DeploySpec::FileSystem.new(directory, stack.environment)
+        Bundler.with_clean_env do
+          capture_all(build_commands(deploy_spec.dependencies_steps, chdir: directory))
+          capture_all(build_commands(deploy_spec.review_checks, chdir: directory))
+        end
+      end
+      self
+    rescue Command::Error
+      self.status = 'failed'
+      self
+    rescue
+      self.status = 'error'
+      raise
+    else
+      self.status = 'success'
+      self
+    end
+
+    def success?
+      status == 'success'
+    end
+
+    def finished?
+      FINAL_STATUSES.include?(status)
+    end
+
+    def write(output)
+      @output ||= ''
+      @output += output
+    end
+
+    private
+
+    def build_commands(commands, chdir:)
+      commands.map { |c| Command.new(c, env: Shipit.env, chdir: chdir) }
+    end
+
+    def capture_all(commands)
+      commands.map { |c| capture(c) }
+    end
+
+    def capture(command)
+      command.start
+      write("$ #{command}\n")
+      command.stream! do |line|
+        write(line)
+      end
+    rescue Command::Error => error
+      write(error.message)
+      raise
+    ensure
+      write("\n")
+    end
+
+    attr_reader :commit
+
+    def stack
+      @stack ||= commit.stack
+    end
+  end
+end

data/app/models/shipit/stack.rb

@@ -58,6 +58,7 @@ module Shipit
     validates :repo_owner, format: {with: /\A[a-z0-9_\-\.]+\z/}, length: {maximum: REPO_OWNER_MAX_SIZE}
     validates :repo_name, format: {with: /\A[a-z0-9_\-\.]+\z/}, length: {maximum: REPO_NAME_MAX_SIZE}
     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 :lock_reason, length: {maximum: 4096}
 
@@ -86,7 +87,7 @@ module Shipit
         definition: find_task_definition(definition_id),
         until_commit_id: commit.id,
         since_commit_id: commit.id,
-        env: filter_task_envs(definition_id, (env || {})),
+        env: filter_task_envs(definition_id, (env.try!(:to_h) || {})),
       )
       task.enqueue
       task
@@ -98,7 +99,7 @@ module Shipit
         user_id: user.id,
         until_commit: until_commit,
         since_commit: since_commit,
-        env: filter_deploy_envs(env || {}),
+        env: filter_deploy_envs(env.try!(:to_h) || {}),
       )
     end
 
@@ -106,17 +107,36 @@ module Shipit
       deploy = build_deploy(*args)
       deploy.save!
       deploy.enqueue
+      continuous_delivery_resumed!
       deploy
     end
 
+    def continuous_delivery_resumed!
+      update!(continuous_delivery_delayed_since: nil)
+    end
+
+    def continuous_delivery_delayed?
+      continuous_delivery_delayed_since? && continuous_deployment? && checks?
+    end
+
+    def continuous_delivery_delayed!
+      touch(:continuous_delivery_delayed_since, :updated_at) unless continuous_delivery_delayed?
+    end
+
     def trigger_continuous_delivery
-      return unless deployable?
-      return if deployed_too_recently?
+      commit = next_commit_to_deploy
 
-      if commit = next_commit_to_deploy
-        return if commit.deployed?
-        trigger_deploy(commit, Shipit.user)
+      if !deployable? || deployed_too_recently? || commit.nil? || commit.deployed?
+        continuous_delivery_resumed!
+        return
       end
+
+      if commit.deploy_failed? || (checks? && !EphemeralCommitChecks.new(commit).run.success?)
+        continuous_delivery_delayed!
+        return
+      end
+
+      trigger_deploy(commit, Shipit.user)
     end
 
     def next_commit_to_deploy
@@ -183,7 +203,7 @@ module Shipit
     end
 
     def last_successful_deploy
-      deploys_and_rollbacks.success.order(created_at: :desc).first
+      deploys_and_rollbacks.success.last
     end
 
     def last_active_task
@@ -238,12 +258,12 @@ module Shipit
       File.join(base_path, "git")
     end
 
-    def acquire_git_cache_lock(timeout: 15, &block)
+    def acquire_git_cache_lock(timeout: 15, expiration: 60, &block)
       Redis::Lock.new(
         "stack:#{id}:git-cache-lock",
         Shipit.redis,
         timeout: timeout,
-        expiration: 60,
+        expiration: expiration,
       ).lock(&block)
     end
 
@@ -298,6 +318,16 @@ module Shipit
       lock_reason.present?
     end
 
+    def lock(reason, user)
+      params = {lock_reason: reason, lock_author: user}
+      params[:locked_since] = Time.current if locked_since.nil?
+      update!(params)
+    end
+
+    def unlock
+      update!(lock_reason: nil, lock_author: nil, locked_since: nil)
+    end
+
     def to_param
       [repo_owner, repo_name, environment].join('/')
     end