shipit-engine 0.5.2 → 0.6.0

data/app/models/shipit/deploy.rb

@@ -0,0 +1,153 @@
+require 'fileutils'
+
+module Shipit
+  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
+end

data/app/models/shipit/deploy_spec.rb

@@ -0,0 +1,150 @@
+require 'pathname'
+
+module Shipit
+  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
+end

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

@@ -0,0 +1,61 @@
+module Shipit
+  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
+end

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

@@ -0,0 +1,29 @@
+module Shipit
+  class DeploySpec
+    module CapistranoDiscovery
+      def discover_deploy_steps
+        discover_capistrano || super
+      end
+
+      def discover_rollback_steps
+        discover_capistrano_rollback || super
+      end
+
+      def discover_capistrano
+        [cap('deploy')] if capistrano?
+      end
+
+      def discover_capistrano_rollback
+        [cap('deploy:rollback')] if capistrano?
+      end
+
+      def cap(command)
+        bundle_exec("cap $ENVIRONMENT #{command}")
+      end
+
+      def capistrano?
+        file('Capfile').exist?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+module Shipit
+  class DeploySpec
+    class FileSystem < DeploySpec
+      include PypiDiscovery
+      include RubygemsDiscovery
+      include CapistranoDiscovery
+      include BundlerDiscovery
+
+      def initialize(app_dir, env)
+        @app_dir = Pathname(app_dir)
+        @env = env
+      end
+
+      def cacheable
+        DeploySpec.new(cacheable_config)
+      end
+
+      private
+
+      def cacheable_config
+        (config || {}).deep_merge(
+          'ci' => {
+            'hide' => hidden_statuses,
+            'allow_failures' => soft_failing_statuses,
+            'require' => required_statuses,
+          },
+          'machine' => {'environment' => machine_env, 'directory' => directory},
+          'review' => {
+            'checklist' => review_checklist,
+            'monitoring' => review_monitoring,
+            'checks' => review_checks,
+          },
+          'plugins' => plugins,
+          'dependencies' => {'override' => dependencies_steps},
+          'deploy' => {'override' => deploy_steps, 'variables' => deploy_variables.map(&:to_h)},
+          'rollback' => {'override' => rollback_steps},
+          'fetch' => fetch_deployed_revision_steps,
+          'tasks' => cacheable_tasks,
+        )
+      end
+
+      def cacheable_tasks
+        (config('tasks') || {}).map { |k, c| [k, coerce_task_definition(c)] }.to_h
+      end
+
+      def config(*)
+        @config ||= load_config
+        super
+      end
+
+      def load_config
+        read_config(file("shipit.#{@env}.yml")) || read_config(file('shipit.yml'))
+      end
+
+      def read_config(path)
+        SafeYAML.load(path.read) if path.exist?
+      end
+
+      def file(path)
+        @app_dir.join(path)
+      end
+    end
+  end
+end