shipit-engine 0.5.2 → 0.6.0

data/app/models/commit_checks.rb

@@ -1,88 +0,0 @@
-class CommitChecks
-  OUTPUT_TTL = 10.minutes.to_i
-  FINAL_STATUSES = %w(failed error success)
-
-  def initialize(commit)
-    @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'
-  end
-
-  def schedule
-    if redis.set('output', '', ex: OUTPUT_TTL, nx: true)
-      self.status = 'scheduled'
-      PerformCommitChecksJob.perform_later(commit: commit)
-    end
-  end
-
-  def status
-    @status ||= redis.get('status')
-  end
-
-  def status=(status)
-    redis.set('status', status, ex: OUTPUT_TTL)
-    @status = status
-  end
-
-  def finished?
-    FINAL_STATUSES.include?(status)
-  end
-
-  def output(since: 0)
-    redis.getrange('output', since, -1)
-  end
-
-  def write(output)
-    redis.append('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 redis
-    @redis ||= Shipit.redis("commit:#{commit.id}:checks")
-  end
-
-  def stack
-    @stack ||= commit.stack
-  end
-end

data/app/models/delivery.rb

@@ -1,45 +0,0 @@
-class Delivery < ActiveRecord::Base
-  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 :content_type, presence: true
-
-  serialize :response_headers, JSON
-
-  def schedule!
-    DeliverHookJob.perform_later(self)
-    scheduled!
-  end
-
-  def send!
-    update!(response: http.post(url, payload), status: 'sent', delivered_at: Time.now)
-  end
-
-  def response=(response)
-    self.response_code = response.status
-    self.response_headers = response.headers
-    self.response_body = response.body
-  end
-
-  private
-
-  def http
-    Faraday::Connection.new do |connection|
-      connection.headers = headers
-      connection.adapter Faraday.default_adapter
-    end
-  end
-
-  def headers
-    {
-      'User-Agent' => 'Shipit Webhook',
-      'Content-Type' => content_type,
-      'X-Shipit-Event' => event,
-      'X-Shipit-Delivery' => id.to_s,
-      'Accept' => '*/*',
-    }
-  end
-end

data/app/models/deploy.rb

@@ -1,151 +0,0 @@
-require 'fileutils'
-
-class Deploy < Task
-  CONFIRMATIONS_REQUIRED = 5
-
-  state_machine :status do
-    after_transition to: :success, do: :schedule_continuous_delivery
-    after_transition to: :success, do: :update_undeployed_commits_count
-    after_transition to: :aborted, do: :trigger_revert_if_required
-  end
-
-  before_create :denormalize_commit_stats
-  after_commit :broadcast_update
-
-  delegate :broadcast_update, to: :stack
-
-  def build_rollback(user = nil, env: nil)
-    Rollback.new(
-      user_id: user.try!(:id),
-      stack_id: stack_id,
-      parent_id: id,
-      since_commit: stack.last_deployed_commit,
-      until_commit: until_commit,
-      env: env || {},
-    )
-  end
-
-  # Rolls the stack back to this deploy
-  def trigger_rollback(user = AnonymousUser.new, env: nil)
-    rollback = build_rollback(user, env: env)
-    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)
-
-    rollback
-  end
-
-  # Rolls the stack back to the **previous** deploy
-  def trigger_revert
-    rollback = Rollback.create!(
-      user_id: user_id,
-      stack_id: stack_id,
-      parent_id: id,
-      since_commit: until_commit,
-      until_commit: since_commit,
-    )
-    rollback.enqueue
-    lock_reason = "A rollback for #{until_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)
-    rollback
-  end
-
-  def rollback?
-    false
-  end
-
-  def commit_range
-    [since_commit, until_commit]
-  end
-
-  delegate :supports_rollback?, to: :stack
-
-  def rollbackable?
-    success? && supports_rollback? && !currently_deployed?
-  end
-
-  def currently_deployed?
-    until_commit_id == stack.last_deployed_commit.try!(:id)
-  end
-
-  def commits
-    return Commit.none unless stack
-
-    @commits ||= stack.commits.reachable.newer_than(since_commit_id).until(until_commit_id).order(id: :desc)
-  end
-
-  def commits_since
-    return Commit.none unless stack
-
-    @commits_since ||= stack.commits.reachable.newer_than(until_commit_id).order(id: :desc)
-  end
-
-  def since_commit_id
-    super || default_since_commit_id
-  end
-
-  def variables
-    stack.deploy_variables
-  end
-
-  def reject!
-    return if failed?
-    transaction do
-      flap! unless flapping?
-      update!(confirmations: [confirmations - 1, -1].min)
-      failure! if confirmed?
-    end
-  end
-
-  def accept!
-    return if success?
-    transaction do
-      flap! unless flapping?
-      update!(confirmations: [confirmations + 1, 1].max)
-      complete! if confirmed?
-    end
-  end
-
-  def confirmed?
-    confirmations.abs >= CONFIRMATIONS_REQUIRED
-  end
-
-  private
-
-  def trigger_revert_if_required
-    return unless rollback_once_aborted?
-    return unless supports_rollback?
-    trigger_revert
-  end
-
-  def default_since_commit_id
-    return unless stack
-    @default_since_commit_id ||= last_successful_deploy.try!(:until_commit_id)
-  end
-
-  def denormalize_commit_stats
-    self.additions = commits.map(&:additions).compact.sum
-    self.deletions = commits.map(&:deletions).compact.sum
-  end
-
-  def schedule_continuous_delivery
-    return unless stack.continuous_deployment?
-
-    to_deploy = stack.commits.order(:id).newer_than(until_commit).successful.last
-    return unless to_deploy
-
-    stack.trigger_deploy(to_deploy, to_deploy.committer)
-  end
-
-  def last_successful_deploy
-    stack.deploys.where(status: "success").last
-  end
-
-  def update_undeployed_commits_count
-    stack.update_undeployed_commits_count(until_commit)
-  end
-end

data/app/models/deploy_spec.rb

@@ -1,148 +0,0 @@
-require 'pathname'
-
-class DeploySpec
-  Error = Class.new(StandardError)
-
-  class << self
-    def load(json)
-      config = json.blank? ? {} : JSON.parse(json)
-      new(config)
-    end
-
-    def dump(spec)
-      JSON.dump(spec.cacheable.config) if spec
-    end
-
-    def bundle_path
-      Rails.root.join('data/bundler')
-    end
-  end
-
-  def initialize(config)
-    @config = config
-  end
-
-  delegate :bundle_path, to: :class
-
-  def cacheable
-    self
-  end
-
-  def config(*keys)
-    keys.flatten.reduce(@config) { |h, k| h[k] if h.respond_to?(:[]) }
-  end
-
-  def supports_fetch_deployed_revision?
-    fetch_deployed_revision_steps.present?
-  end
-
-  def supports_rollback?
-    rollback_steps.present?
-  end
-
-  def machine_env
-    config('machine', 'environment') || {}
-  end
-
-  def directory
-    config('machine', 'directory')
-  end
-
-  def dependencies_steps
-    config('dependencies', 'override') || discover_dependencies_steps || []
-  end
-  alias_method :dependencies_steps!, :dependencies_steps
-
-  def deploy_steps
-    config('deploy', 'override') || discover_deploy_steps
-  end
-
-  def deploy_steps!
-    deploy_steps || cant_detect!(:deploy)
-  end
-
-  def deploy_variables
-    Array.wrap(config('deploy', 'variables')).map(&VariableDefinition.method(:new))
-  end
-
-  def rollback_steps
-    config('rollback', 'override') || discover_rollback_steps
-  end
-
-  def rollback_steps!
-    rollback_steps || cant_detect!(:rollback)
-  end
-
-  def fetch_deployed_revision_steps
-    config('fetch') || discover_fetch_deployed_revision_steps
-  end
-
-  def fetch_deployed_revision_steps!
-    fetch_deployed_revision_steps || cant_detect!(:fetch)
-  end
-
-  def task_definitions
-    (config('tasks') || {}).map { |name, definition| TaskDefinition.new(name, coerce_task_definition(definition)) }
-  end
-
-  def find_task_definition(id)
-    TaskDefinition.new(id, coerce_task_definition(config('tasks', id)) || task_not_found!(id))
-  end
-
-  def review_checklist
-    (config('review', 'checklist') || discover_review_checklist || []).map(&:strip).select(&:present?)
-  end
-
-  def review_monitoring
-    (config('review', 'monitoring') || []).select(&:present?)
-  end
-
-  def hidden_statuses
-    Array.wrap(config('ci', 'hide'))
-  end
-
-  def required_statuses
-    Array.wrap(config('ci', 'require'))
-  end
-
-  def soft_failing_statuses
-    Array.wrap(config('ci', 'allow_failures'))
-  end
-
-  def review_checks
-    config('review', 'checks') || []
-  end
-
-  def plugins
-    config('plugins') || {}
-  end
-
-  private
-
-  def coerce_task_definition(config)
-    config
-  end
-
-  def discover_review_checklist
-  end
-
-  def discover_dependencies_steps
-  end
-
-  def discover_deploy_steps
-  end
-
-  def discover_rollback_steps
-  end
-
-  def discover_fetch_deployed_revision_steps
-  end
-
-  def task_not_found!(id)
-    raise TaskDefinition::NotFound.new("No definition for task #{id.inspect}")
-  end
-
-  def cant_detect!(type)
-    raise DeploySpec::Error.new(I18n.t("deploy_spec.hint.#{type}"))
-  end
-end

data/app/models/deploy_spec/bundler_discovery.rb

@@ -1,59 +0,0 @@
-class DeploySpec
-  module BundlerDiscovery
-    DEFAULT_BUNDLER_WITHOUT = %w(default production development test staging benchmark debug)
-
-    def discover_dependencies_steps
-      discover_bundler || super
-    end
-
-    def discover_bundler
-      bundle_install if bundler?
-    end
-
-    def bundle_exec(command)
-      return command unless bundler?
-      "bundle exec #{command}"
-    end
-
-    def bundle_install
-      bundle = %(bundle check --path=#{bundle_path} || bundle install #{frozen_flag} --path=#{bundle_path} --retry=2)
-      bundle += " --without=#{bundler_without.join(':')}" unless bundler_without.empty?
-      [remove_ruby_version_from_gemfile, bundle]
-    end
-
-    def remove_ruby_version_from_gemfile
-      # Heroku apps often specify a ruby version.
-      if /darwin/ =~ RUBY_PLATFORM
-        # OSX is nitpicky about the -i.
-        %q(sed -i '' '/^ruby\s/d' Gemfile)
-      else
-        %q(sed -i '/^ruby\s/d' Gemfile)
-      end
-    end
-
-    def frozen_flag
-      return unless gemfile_lock_exists?
-      return if config('dependencies', 'bundler', 'frozen') == false
-      '--frozen'
-    end
-
-    def bundler_without
-      config('dependencies', 'bundler', 'without') || (gem? ? [] : DEFAULT_BUNDLER_WITHOUT)
-    end
-
-    def bundler?
-      file('Gemfile').exist?
-    end
-
-    def gemfile_lock_exists?
-      file('Gemfile.lock').exist?
-    end
-
-    def coerce_task_definition(config)
-      return super unless bundler?
-      config['steps'] ||= []
-      config['steps'] = config['steps'].map(&method(:bundle_exec))
-      config
-    end
-  end
-end