shipit-engine 0.0.1.pre

data/app/models/delivery.rb

@@ -0,0 +1,45 @@
+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

@@ -0,0 +1,92 @@
+require 'fileutils'
+
+class Deploy < Task
+  state_machine :status do
+    after_transition to: :success, do: :schedule_continuous_delivery
+    after_transition to: :success, do: :update_undeployed_commits_count
+  end
+
+  before_create :denormalize_commit_stats
+  after_commit :broadcast_update
+
+  delegate :broadcast_update, to: :stack
+
+  def build_rollback(user = 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,
+    )
+  end
+
+  def trigger_rollback(user)
+    rollback = build_rollback(user)
+    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
+
+  def rollback?
+    false
+  end
+
+  def commit_range
+    [since_commit, until_commit]
+  end
+
+  def rollbackable?
+    stack.supports_rollback? && success? && self != stack.last_deploy
+  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
+
+  private
+
+  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/bundler_discovery.rb

@@ -0,0 +1,51 @@
+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
+      %q(sed -i '/^ruby\s/d' Gemfile) # Heroku apps often specify a ruby version.
+    end
+
+    def frozen_flag
+      '--frozen' if gemfile_lock_exists?
+    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

data/app/models/deploy_spec/capistrano_discovery.rb

@@ -0,0 +1,27 @@
+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

data/app/models/deploy_spec/file_system.rb

@@ -0,0 +1,52 @@
+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(
+        'machine' => {'environment' => machine_env, 'directory' => directory},
+        'review' => {'checklist' => review_checklist},
+        'dependencies' => {'override' => dependencies_steps},
+        'deploy' => {'override' => deploy_steps},
+        '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

data/app/models/deploy_spec/pypi_discovery.rb

@@ -0,0 +1,32 @@
+class DeploySpec
+  module PypiDiscovery
+    def discover_deploy_steps
+      discover_pypi || super
+    end
+
+    def discover_pypi
+      publish_egg if egg?
+    end
+
+    def discover_review_checklist
+      discover_pypi_checklist || super
+    end
+
+    def discover_pypi_checklist
+      [%(<strong>Don't forget to add a tag before deploying!</strong> You can do this with:
+        git tag -a -m "Version <strong>x.y.z</strong>" v<strong>x.y.z</strong> && git push --tags)] if egg?
+    end
+
+    def egg?
+      setup_dot_py.exist?
+    end
+
+    def setup_dot_py
+      file('setup.py')
+    end
+
+    def publish_egg
+      ["assert-egg-version-tag #{setup_dot_py}", 'python setup.py register sdist upload']
+    end
+  end
+end

data/app/models/deploy_spec/rubygems_discovery.rb

@@ -0,0 +1,32 @@
+class DeploySpec
+  module RubygemsDiscovery
+    def discover_deploy_steps
+      discover_gem || super
+    end
+
+    def discover_gem
+      publish_gem if gem?
+    end
+
+    def discover_review_checklist
+      discover_gem_checklist || super
+    end
+
+    def discover_gem_checklist
+      [%(<strong>Don't forget to add a tag before deploying!</strong> You can do this with:
+        git tag -a -m "Version <strong>x.y.z</strong>" v<strong>x.y.z</strong> && git push --tags)] if gem?
+    end
+
+    def gem?
+      !!gemspec
+    end
+
+    def gemspec
+      Dir[file('*.gemspec').to_s].first
+    end
+
+    def publish_gem
+      ["assert-gem-version-tag #{gemspec}", 'bundle exec rake release']
+    end
+  end
+end

data/app/models/deploy_spec.rb

@@ -0,0 +1,123 @@
+require 'pathname'
+
+class DeploySpec
+  Error = Class.new(StandardError)
+
+  class << self
+    def load(json)
+      new(JSON.parse(json)) if json.present?
+    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 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 || []
+  end
+
+  def review_monitoring
+    config('review', 'monitoring') || []
+  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