shipit-engine 0.0.1.pre

data/app/models/github_hook.rb

@@ -0,0 +1,144 @@
+class GithubHook < ActiveRecord::Base
+  include SecureCompare
+
+  before_create :generate_secret
+  before_destroy :teardown!
+
+  def verify_signature(signature, message)
+    algorithm, signature = signature.split("=", 2)
+    return false unless algorithm == 'sha1'
+
+    secure_compare(signature, OpenSSL::HMAC.hexdigest(algorithm, secret, message))
+  end
+
+  delegate :github_repo_name, to: :stack
+  def setup!
+    hook = already_setup? ? update_hook! : create_hook!
+    update!(github_id: hook.id, api_url: hook.rels[:self].href)
+  end
+
+  def schedule_setup!
+    SetupGithubHookJob.perform_later(self)
+  end
+
+  def teardown!
+    destroy_hook! if already_setup?
+    true
+  end
+
+  def event=(event)
+    super(event.to_s)
+  end
+
+  def already_setup?
+    github_id?
+  end
+
+  private
+
+  def update_hook!
+    edit_hook!
+  rescue Octokit::NotFound
+    create_hook!
+  end
+
+  private
+
+  def endpoint_url
+    raise NotImplementedError.new('Subclasses must implement a `endpoint_url` method')
+  end
+
+  def hook_properties
+    {url: endpoint_url, content_type: 'json', secret: secret}
+  end
+
+  def generate_secret
+    self.secret = SecureRandom.hex
+  end
+
+  def url_helpers
+    Shipit::Engine.routes.url_helpers
+  end
+
+  def host
+    Shipit.host
+  end
+
+  def api
+    Shipit.github_api
+  end
+
+  class Repo < GithubHook
+    belongs_to :stack, required: true
+
+    private
+
+    def create_hook!
+      api.create_hook(github_repo_name, 'web', properties, events: [event], active: true)
+    end
+
+    def edit_hook!
+      api.edit_hook(github_repo_name, github_id, 'web', properties, events: [event], active: true)
+    end
+
+    def destroy_hook!
+      api.remove_hook(github_repo_name, github_id)
+    rescue Octokit::NotFound
+    end
+
+    def properties
+      {
+        url: endpoint_url,
+        content_type: 'json',
+        secret: secret,
+      }
+    end
+
+    def endpoint_url
+      case event
+      when 'push'
+        url_helpers.push_stack_webhooks_url(stack_id, host: host)
+      when 'status'
+        url_helpers.state_stack_webhooks_url(stack_id, host: host)
+      else
+        raise ArgumentError, "Unknown GithubHook::Repo event: `#{event.inspect}`"
+      end
+    end
+  end
+
+  class Organization < GithubHook
+    validates :organization, presence: true
+
+    private
+
+    def create_hook!
+      api.create_org_hook(organization, properties, events: [event], active: true)
+    end
+
+    def edit_hook!
+      api.edit_org_hook(organization, github_id, properties, events: [event], active: true)
+    end
+
+    def destroy_hook!
+      api.remove_org_hook(organization, github_id)
+    rescue Octokit::NotFound
+    end
+
+    def properties
+      {
+        url: endpoint_url,
+        content_type: 'json',
+        secret: secret,
+      }
+    end
+
+    def endpoint_url
+      case event
+      when 'membership'
+        url_helpers.membership_webhooks_url(host: host)
+      else
+        raise ArgumentError, "Unknown GithubHook::Organization event: `#{event.inspect}`"
+      end
+    end
+  end
+end

data/app/models/hook.rb

@@ -0,0 +1,86 @@
+class Hook < ActiveRecord::Base
+  default_scope { order :id }
+
+  CONTENT_TYPES = {
+    'json' => 'application/json',
+    'form' => 'application/x-www-form-urlencoded',
+  }.freeze
+
+  EVENTS = %w(
+    task
+    deploy
+    rollback
+    lock
+  ).freeze
+
+  belongs_to :stack, required: false
+  has_many :deliveries
+
+  validates :url, presence: true, url: {no_local: true, allow_blank: true}
+  validates :content_type, presence: true, inclusion: {in: CONTENT_TYPES.keys}
+  validates :events, presence: true, subset: {of: EVENTS}
+
+  serialize :events, Shipit::CSVSerializer
+
+  scope :global, -> { where(stack_id: nil) }
+  scope :scoped_to, -> (stack) { where(stack_id: stack.id) }
+  scope :for_stack, -> (stack_id) { where(stack_id: [nil, stack_id]) }
+
+  class << self
+    def emit(event, stack, payload)
+      EmitEventJob.perform_later(
+        event: event.to_s,
+        stack_id: stack.try!(:id),
+        payload: coerce_payload(payload),
+      )
+    end
+
+    def deliver(event, stack_id, payload)
+      for_stack(stack_id).listening_event(event).each do |hook|
+        hook.deliver!(event, payload)
+      end
+    end
+
+    def listening_event(event)
+      event = event.to_s
+      all.to_a.select { |h| h.events.include?(event) }
+    end
+
+    def coerce_payload(payload)
+      coerced_payload = payload.dup
+      payload.each do |key, value|
+        if serializer = ActiveModel::Serializer.serializer_for(value)
+          coerced_payload[key] = serializer.new(value)
+        end
+      end
+      coerced_payload.to_json
+    end
+  end
+
+  def global?
+    !stack_id?
+  end
+
+  def scoped?
+    stack_id?
+  end
+
+  def deliver!(event, payload)
+    deliveries.create!(
+      event: event,
+      url: url,
+      content_type: CONTENT_TYPES[content_type],
+      payload: serialize_payload(payload),
+    ).schedule!
+  end
+
+  private
+
+  def serialize_payload(payload)
+    if content_type == 'form'
+      payload.to_query
+    else
+      JSON.pretty_generate(payload)
+    end
+  end
+end

data/app/models/membership.rb

@@ -0,0 +1,6 @@
+class Membership < ActiveRecord::Base
+  belongs_to :team, required: true
+  belongs_to :user, required: true
+
+  validates :user_id, uniqueness: {scope: :team_id}
+end

data/app/models/output_chunk.rb

@@ -0,0 +1,9 @@
+class OutputChunk < ActiveRecord::Base
+  belongs_to :task
+
+  scope :tail, -> (start) { where('id > ?', start || 0) }
+
+  def text=(string)
+    super(string.force_encoding(Encoding::UTF_8).scrub)
+  end
+end

data/app/models/rollback.rb

@@ -0,0 +1,19 @@
+class Rollback < Deploy
+  def rollback?
+    true
+  end
+
+  def commits
+    return Commit.none unless stack
+
+    @commits ||= stack.commits.reachable.newer_than(until_commit_id).until(since_commit_id).order(id: :asc)
+  end
+
+  def commit_range
+    [until_commit, since_commit]
+  end
+
+  def to_partial_path
+    'deploys/deploy'
+  end
+end

data/app/models/stack.rb

@@ -0,0 +1,276 @@
+require 'fileutils'
+
+class Stack < ActiveRecord::Base
+  REQUIRED_HOOKS = %i(push status)
+
+  has_many :commits, dependent: :destroy
+  has_many :tasks, dependent: :destroy
+  has_many :deploys
+  has_many :rollbacks
+  has_many :github_hooks, dependent: :destroy, class_name: 'GithubHook::Repo'
+  has_many :hooks, dependent: :destroy
+  has_many :api_clients, dependent: :destroy
+  belongs_to :lock_author, class_name: :User
+
+  before_validation :update_defaults
+  before_destroy :clear_local_files
+  after_commit :emit_hooks
+  after_commit :broadcast_update, on: :update
+  after_commit :setup_hooks, :sync_github, on: :create
+  after_touch :clear_cache
+
+  validates :repo_name, uniqueness: {scope: %i(repo_owner environment)}
+  validates :repo_owner, :repo_name, presence: true, format: {with: /\A[a-z0-9_\-\.]+\z/}
+  validates :environment, presence: true, format: {with: /\A[a-z0-9\-_\:]+\z/}
+
+  serialize :cached_deploy_spec, DeploySpec
+  delegate :find_task_definition, :supports_rollback?,
+           :supports_fetch_deployed_revision?, to: :cached_deploy_spec, allow_nil: true
+
+  def self.refresh_deployed_revisions
+    find_each.select(&:supports_fetch_deployed_revision?).each(&:async_refresh_deployed_revision)
+  end
+
+  def undeployed_commits?
+    undeployed_commits_count > 0
+  end
+
+  def trigger_task(definition_id, user)
+    commit = last_deployed_commit
+    task = tasks.create(
+      user_id: user.id,
+      definition: find_task_definition(definition_id),
+      until_commit_id: commit.id,
+      since_commit_id: commit.id,
+    )
+    task.enqueue
+    task
+  end
+
+  def trigger_deploy(until_commit, user)
+    since_commit = last_deployed_commit
+
+    deploy = deploys.create(
+      user_id: user.id,
+      until_commit: until_commit,
+      since_commit: since_commit,
+    )
+    deploy.enqueue
+    deploy
+  end
+
+  def async_refresh_deployed_revision
+    FetchDeployedRevisionJob.perform_later(self)
+  end
+
+  def update_deployed_revision(sha)
+    return if deploying?
+
+    actual_deployed_commit = commits.reachable.by_sha!(sha)
+
+    recorded_last_deployed_commit = last_deployed_commit
+    return if recorded_last_deployed_commit.id == actual_deployed_commit.id
+
+    deploys.create!(
+      until_commit: actual_deployed_commit,
+      since_commit: recorded_last_deployed_commit,
+      status: 'success',
+    )
+  end
+
+  def task_definitions
+    cached_deploy_spec.try!(:task_definitions) || []
+  end
+
+  def head
+    commits.reachable.first.try(:sha)
+  end
+
+  def status
+    return :deploying if deploying?
+    :default
+  end
+
+  def last_deploy
+    @last_deploy ||= deploys.last
+  end
+
+  def last_successful_deploy
+    deploys.success.last
+  end
+
+  def last_deployed_commit
+    if deploy = last_successful_deploy
+      deploy.until_commit
+    else
+      commits.first
+    end
+  end
+
+  def deployable?
+    !locked? && !deploying?
+  end
+
+  def repo_name=(name)
+    super(name.try(:downcase))
+  end
+
+  def repo_owner=(name)
+    super(name.try(:downcase))
+  end
+
+  def repo_http_url
+    "https://github.com/#{repo_owner}/#{repo_name}"
+  end
+
+  def repo_git_url
+    "git@github.com:#{repo_owner}/#{repo_name}.git"
+  end
+
+  def base_path
+    Rails.root.join('data/stacks', repo_owner, repo_name, environment)
+  end
+
+  def deploys_path
+    File.join(base_path, "deploys")
+  end
+
+  def git_path
+    File.join(base_path, "git")
+  end
+
+  def acquire_git_cache_lock(timeout: 15, &block)
+    Redis::Lock.new(
+      "stack:#{id}:git-cache-lock",
+      Shipit.redis,
+      timeout: timeout,
+      expiration: 60,
+    ).lock(&block)
+  end
+
+  def clear_git_cache!
+    tmp_path = "#{git_path}-#{SecureRandom.hex}"
+    acquire_git_cache_lock do
+      return unless File.exist?(git_path)
+      File.rename(git_path, tmp_path)
+    end
+    FileUtils.rm_rf(tmp_path)
+  end
+
+  def github_repo_name
+    [repo_owner, repo_name].join('/')
+  end
+
+  def github_repo
+    Shipit.github_api.repo(github_repo_name)
+  end
+
+  def github_commits
+    Shipit.github_api.commits(github_repo_name, sha: branch)
+  end
+
+  def deploying?
+    !!active_deploy
+  end
+
+  def active_deploy
+    return @active_deploy if defined?(@active_deploy)
+    @active_deploy ||= deploys.active.last
+  end
+
+  def locked?
+    lock_reason.present?
+  end
+
+  def to_param
+    [repo_owner, repo_name, environment].join('/')
+  end
+
+  def self.from_param!(param)
+    repo_owner, repo_name, environment = param.split('/')
+    where(
+      repo_owner: repo_owner.downcase,
+      repo_name: repo_name.downcase,
+      environment: environment,
+    ).first!
+  end
+
+  def monitoring?
+    monitoring.present?
+  end
+
+  def monitoring
+    return [] unless cached_deploy_spec
+    cached_deploy_spec.review_monitoring.select(&:present?)
+  end
+
+  def checklist?
+    checklist.present?
+  end
+
+  def checklist
+    return [] unless cached_deploy_spec
+    cached_deploy_spec.review_checklist.map(&:strip).select(&:present?)
+  end
+
+  def update_undeployed_commits_count(after_commit = nil)
+    after_commit ||= last_deployed_commit
+    undeployed_commits = commits.reachable.select('count(*) as count').where('id > ?', after_commit.id)
+    self.class.where(id: id).update_all("undeployed_commits_count = (#{undeployed_commits.to_sql})")
+  end
+
+  def broadcast_update
+    payload = {url: Shipit::Engine.routes.url_helpers.stack_path(self)}.to_json
+    event = Pubsubstub::Event.new(payload, name: "stack.update")
+    Pubsubstub::RedisPubSub.publish("stack.#{id}", event)
+  end
+
+  def setup_hooks
+    REQUIRED_HOOKS.each do |event|
+      hook = github_hooks.find_or_create_by!(event: event)
+      hook.schedule_setup!
+    end
+  end
+
+  def schedule_for_destroy!
+    DestroyStackJob.perform_later(self)
+  end
+
+  def ci_enabled?
+    Rails.cache.fetch(ci_enabled_cache_key) do
+      commits.joins(:statuses).any?
+    end
+  end
+
+  def enable_ci!
+    Rails.cache.write(ci_enabled_cache_key, true)
+  end
+
+  private
+
+  def clear_cache
+    remove_instance_variable(:@active_deploy) if defined?(@active_deploy)
+  end
+
+  def sync_github
+    GithubSyncJob.perform_later(stack_id: id)
+  end
+
+  def clear_local_files
+    FileUtils.rm_rf(base_path.to_s)
+  end
+
+  def update_defaults
+    self.environment = 'production' if environment.blank?
+    self.branch = 'master' if branch.blank?
+  end
+
+  def emit_hooks
+    return unless previous_changes.include?('lock_reason')
+    Hook.emit(:lock, self, locked: locked?, stack: self)
+  end
+
+  def ci_enabled_cache_key
+    "stacks:#{id}:ci_enabled"
+  end
+end