shipit-engine 0.5.2 → 0.6.0

data/app/helpers/tasks_helper.rb

@@ -1,9 +0,0 @@
-module TasksHelper
-  def task_description(task)
-    if task.class == Task
-      task.definition.action
-    else
-      t("#{task.class.name.underscore.pluralize}.description", sha: task.until_commit.short_sha)
-    end
-  end
-end

data/app/jobs/background_job.rb

@@ -1,22 +0,0 @@
-class BackgroundJob < ActiveJob::Base
-  class << self
-    attr_accessor :timeout
-  end
-
-  def perform(*)
-    with_timeout do
-      super
-    end
-  end
-
-  private
-
-  def with_timeout(&block)
-    return yield unless timeout
-    Timeout.timeout(timeout, &block)
-  end
-
-  def logger
-    Rails.logger
-  end
-end

data/app/jobs/background_job/unique.rb

@@ -1,26 +0,0 @@
-class BackgroundJob
-  module Unique
-    extend ActiveSupport::Concern
-
-    DEFAULT_TIMEOUT = 10
-
-    included do
-      around_perform { |job, block| job.acquire_lock(&block) }
-      cattr_accessor :lock_timeout
-    end
-
-    def acquire_lock(&block)
-      mutex = Redis::Lock.new(
-        lock_key(*arguments),
-        Shipit.redis,
-        expiration: self.class.timeout || DEFAULT_TIMEOUT,
-        timeout: self.class.lock_timeout || 0,
-      )
-      mutex.lock(&block)
-    end
-
-    def lock_key(*args)
-      ActiveJob::Arguments.serialize([self.class.name] + args).join('-')
-    end
-  end
-end

data/app/jobs/cache_deploy_spec_job.rb

@@ -1,10 +0,0 @@
-class CacheDeploySpecJob < BackgroundJob
-  include BackgroundJob::Unique
-
-  def perform(stack)
-    commands = Commands.for(stack)
-    commands.with_temporary_working_directory(commit: stack.commits.last) do |path|
-      stack.update!(cached_deploy_spec: DeploySpec::FileSystem.new(path, stack.environment))
-    end
-  end
-end

data/app/jobs/chunk_rollup_job.rb

@@ -1,19 +0,0 @@
-class ChunkRollupJob < BackgroundJob
-  include BackgroundJob::Unique
-
-  queue_as :default
-
-  def perform(task)
-    unless task.finished?
-      logger.error("Task ##{task.id} is not finished (current state: #{task.status}). Aborting.")
-      return
-    end
-
-    if task.rolled_up?
-      logger.error("Task ##{task.id} has already been rolled up. Aborting.")
-      return
-    end
-
-    task.rollup_chunks
-  end
-end

data/app/jobs/clear_git_cache_job.rb

@@ -1,7 +0,0 @@
-class ClearGitCacheJob < BackgroundJob
-  queue_as :default
-
-  def perform(stack)
-    stack.clear_git_cache!
-  end
-end

data/app/jobs/deliver_hook_job.rb

@@ -1,7 +0,0 @@
-class DeliverHookJob < BackgroundJob
-  queue_as :hooks
-
-  def perform(delivery)
-    delivery.send!
-  end
-end

data/app/jobs/destroy_stack_job.rb

@@ -1,7 +0,0 @@
-class DestroyStackJob < BackgroundJob
-  queue_as :default
-
-  def perform(stack)
-    stack.destroy!
-  end
-end

data/app/jobs/emit_event_job.rb

@@ -1,8 +0,0 @@
-class EmitEventJob < BackgroundJob
-  queue_as :hooks
-
-  def perform(params)
-    event, stack_id, payload = params.with_indifferent_access.values_at('event', 'stack_id', 'payload')
-    Hook.deliver(event, stack_id, JSON.load(payload))
-  end
-end

data/app/jobs/fetch_commit_stats_job.rb

@@ -1,7 +0,0 @@
-class FetchCommitStatsJob < BackgroundJob
-  queue_as :default
-
-  def perform(commit)
-    commit.fetch_stats!
-  end
-end

data/app/jobs/fetch_deployed_revision_job.rb

@@ -1,21 +0,0 @@
-class FetchDeployedRevisionJob < BackgroundJob
-  queue_as :default
-
-  def perform(stack)
-    return if stack.deploying?
-
-    commands = StackCommands.new(stack)
-
-    begin
-      sha = commands.fetch_deployed_revision
-    rescue DeploySpec::Error
-    end
-
-    return unless sha.present?
-
-    begin
-      stack.update_deployed_revision(sha)
-    rescue ActiveRecord::RecordNotFound
-    end
-  end
-end

data/app/jobs/git_mirror_update_job.rb

@@ -1,10 +0,0 @@
-class GitMirrorUpdateJob < BackgroundJob
-  queue_as :default
-
-  def perform(stack)
-    commands = StackCommands.new(stack)
-    stack.acquire_git_cache_lock do
-      commands.fetch.run
-    end
-  end
-end

data/app/jobs/github_sync_job.rb

@@ -1,53 +0,0 @@
-class GithubSyncJob < BackgroundJob
-  include BackgroundJob::Unique
-
-  MAX_FETCHED_COMMITS = 10
-  queue_as :default
-
-  self.timeout = 60
-  self.lock_timeout = 20
-
-  def perform(params)
-    @stack = Stack.find(params[:stack_id])
-
-    handle_github_errors do
-      new_commits, shared_parent = fetch_missing_commits { @stack.github_commits }
-
-      @stack.transaction do
-        shared_parent.try!(:detach_children!)
-        new_commits.each do |gh_commit|
-          @stack.commits.create_from_github!(gh_commit)
-        end
-      end
-    end
-    CacheDeploySpecJob.perform_later(@stack)
-  end
-
-  def fetch_missing_commits(&block)
-    commits = []
-    iterator = Shipit::FirstParentCommitsIterator.new(&block)
-    iterator.each_with_index do |commit, index|
-      break if index >= MAX_FETCHED_COMMITS
-
-      if shared_parent = lookup_commit(commit.sha)
-        return commits, shared_parent
-      end
-      commits.unshift(commit)
-    end
-    return commits, nil
-  end
-
-  protected
-
-  def handle_github_errors
-    yield
-  rescue Octokit::NotFound
-    @stack.mark_as_inaccessible!
-  else
-    @stack.mark_as_accessible!
-  end
-
-  def lookup_commit(sha)
-    @stack.commits.find_by_sha(sha)
-  end
-end

data/app/jobs/perform_commit_checks_job.rb

@@ -1,5 +0,0 @@
-class PerformCommitChecksJob < BackgroundJob
-  def perform(commit:)
-    commit.checks.run
-  end
-end

data/app/jobs/perform_task_job.rb

@@ -1,55 +0,0 @@
-class PerformTaskJob < BackgroundJob
-  queue_as :deploys
-
-  def perform(task)
-    @task = task
-    @commands = Commands.for(@task)
-    unless @task.pending?
-      logger.error("Task ##{@task.id} already in `#{@task.status}` state. Aborting.")
-      return
-    end
-    run
-  ensure
-    @task.clear_working_directory
-  end
-
-  def run
-    @task.run!
-    checkout_repository
-    perform_task
-    @task.complete!
-  rescue Command::Error => error
-    @task.report_failure!(error)
-  rescue StandardError => error
-    @task.report_error!(error)
-  end
-
-  def perform_task
-    Bundler.with_clean_env do
-      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
-    end
-    capture @commands.checkout(@task.until_commit)
-  end
-
-  def capture_all(commands)
-    commands.map { |c| capture(c) }
-  end
-
-  def capture(command)
-    command.start
-    @task.write("$ #{command}\npid: #{command.pid}\n")
-    @task.pid = command.pid
-    command.stream! do |line|
-      @task.write(line)
-    end
-    @task.write("\n")
-  end
-end

data/app/jobs/refresh_github_user_job.rb

@@ -1,7 +0,0 @@
-class RefreshGithubUserJob < BackgroundJob
-  queue_as :default
-
-  def perform(user)
-    user.refresh_from_github!
-  end
-end

data/app/jobs/refresh_statuses_job.rb

@@ -1,12 +0,0 @@
-class RefreshStatusesJob < BackgroundJob
-  queue_as :default
-
-  def perform(params)
-    if params[:commit_id]
-      Commit.find(params[:commit_id]).refresh_statuses!
-    else
-      stack = Stack.find(params[:stack_id])
-      stack.commits.order(id: :desc).limit(30).each(&:refresh_statuses!)
-    end
-  end
-end

data/app/jobs/setup_github_hook_job.rb

@@ -1,9 +0,0 @@
-class SetupGithubHookJob < BackgroundJob
-  include BackgroundJob::Unique
-
-  queue_as :default
-
-  def perform(hook)
-    hook.setup!
-  end
-end

data/app/models/anonymous_user.rb

@@ -1,41 +0,0 @@
-class AnonymousUser
-  def email
-    'anonymous@example.com'
-  end
-
-  def login
-    'anonymous'
-  end
-
-  def name
-    'Anonymous'
-  end
-
-  def avatar_url
-    'https://github.com/images/error/octocat_happy.gif'
-  end
-
-  def id
-  end
-
-  def logged_in?
-    false
-  end
-
-  def stacks_contributed_to
-    []
-  end
-
-  def avatar_uri
-    User::DEFAULT_AVATAR.dup
-  end
-
-  def created_at
-    Time.at(0).utc
-  end
-  alias_method :updated_at, :created_at
-
-  def read_attribute_for_serialization(attr)
-    public_send(attr)
-  end
-end

data/app/models/api_client.rb

@@ -1,42 +0,0 @@
-class ApiClient < ActiveRecord::Base
-  InsufficientPermission = Class.new(StandardError)
-
-  belongs_to :creator, class_name: 'User'
-  belongs_to :stack
-
-  validates :creator, :name, presence: true
-
-  serialize :permissions, Array
-  PERMISSIONS = %w(
-    read:stack
-    write:stack
-    deploy:stack
-    lock:stack
-    read:hook
-    write:hook
-  ).freeze
-  validates :permissions, subset: {of: PERMISSIONS}
-
-  class << self
-    def authenticate(token)
-      find_by_id(message_verifier.verify(token).to_i)
-    rescue Shipit::SimpleMessageVerifier::InvalidSignature
-    end
-
-    def message_verifier
-      @message_verifier ||= Shipit::SimpleMessageVerifier.new(Shipit.api_clients_secret)
-    end
-  end
-
-  def authentication_token
-    self.class.message_verifier.generate(id)
-  end
-
-  def check_permissions!(operation, scope)
-    required_permission = "#{operation}:#{scope}"
-    unless permissions.include?(required_permission)
-      raise InsufficientPermission, "This operation requires the `#{required_permission}` permission"
-    end
-    true
-  end
-end

data/app/models/commit.rb

@@ -1,207 +0,0 @@
-class Commit < ActiveRecord::Base
-  AmbiguousRevision = Class.new(StandardError)
-
-  belongs_to :stack, touch: true
-  has_many :deploys
-  has_many :statuses, -> { order(created_at: :desc) }
-
-  after_commit { broadcast_update }
-  after_create { stack.update_undeployed_commits_count }
-
-  after_commit :schedule_refresh_statuses!, :schedule_fetch_stats!, on: :create
-
-  after_touch :touch_stack
-
-  belongs_to :author, class_name: 'User', inverse_of: :authored_commits
-  belongs_to :committer, class_name: 'User', inverse_of: :commits
-
-  scope :reachable, -> { where(detached: false) }
-
-  delegate :broadcast_update, :github_repo_name, to: :stack
-
-  def self.newer_than(commit)
-    return all unless commit
-    where('id > ?', commit.is_a?(Commit) ? commit.id : commit)
-  end
-
-  def self.until(commit)
-    return all unless commit
-    where('id <= ?', commit.is_a?(Commit) ? commit.id : commit)
-  end
-
-  def self.successful
-    preload(:statuses).to_a.select(&:success?)
-  end
-
-  def self.detach!
-    Commit.where(id: ids).update_all(detached: true)
-  end
-
-  def self.by_sha(sha)
-    if sha.to_s.size < 6
-      raise AmbiguousRevision, "Short SHA1 #{sha} is ambiguous (too short)"
-    end
-
-    commits = where('sha like ?', "#{sha}%").take(2)
-    raise AmbiguousRevision, "Short SHA1 #{sha} is ambiguous (matches multiple commits)" if commits.size > 1
-    commits.first
-  end
-
-  def self.by_sha!(sha)
-    by_sha(sha) || raise(ActiveRecord::RecordNotFound, "Couldn't find commit with sha #{sha}")
-  end
-
-  def self.from_github(commit)
-    new(
-      sha: commit.sha,
-      message: commit.commit.message,
-      author: User.find_or_create_from_github(commit.author || commit.commit.author),
-      committer: User.find_or_create_from_github(commit.committer || commit.commit.committer),
-      committed_at: commit.commit.committer.date,
-      authored_at: commit.commit.author.date,
-      additions: commit.stats.try!(:additions),
-      deletions: commit.stats.try!(:deletions),
-    )
-  end
-
-  def reload(*)
-    @last_statuses = nil
-    super
-  end
-
-  def self.create_from_github!(commit)
-    from_github(commit).save!
-  end
-
-  def schedule_refresh_statuses!
-    RefreshStatusesJob.perform_later(commit_id: id)
-  end
-
-  def refresh_statuses!
-    Shipit.github_api.statuses(github_repo_name, sha).each do |status|
-      statuses.replicate_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 simple_state(previous_status) != simple_state(new_status) && !new_status.pending?
-      Hook.emit(:deployable_status, stack, payload.merge(deployable_status: new_status))
-    end
-    new_status
-  end
-
-  def checks
-    @checks ||= CommitChecks.new(self)
-  end
-
-  delegate :pending?, :success?, :error?, :failure?, :state, to: :status
-
-  def deployable?
-    success? || stack.ignore_ci?
-  end
-
-  def children
-    self.class.where(stack_id: stack_id).newer_than(self)
-  end
-
-  def detach_children!
-    children.detach!
-  end
-
-  def pull_request_url
-    parsed && Shipit.github_url("/#{stack.repo_owner}/#{stack.repo_name}/pull/#{pull_request_id}")
-  end
-
-  def pull_request_id
-    parsed && parsed['pr_id'].to_i
-  end
-
-  def pull_request_title
-    parsed && parsed['pr_title']
-  end
-
-  def pull_request?
-    !!parsed
-  end
-
-  def short_sha
-    sha[0..9]
-  end
-
-  def parsed
-    @parsed ||= message.match(/\AMerge pull request #(?<pr_id>\d+) from [\w\-.\/]+\n\n(?<pr_title>.*)/)
-  end
-
-  def schedule_continuous_delivery
-    return unless state == 'success' && stack.continuous_deployment?
-    return unless stack.deployable?
-    return if already_deployed?
-    stack.trigger_deploy(self, committer)
-  end
-
-  def github_commit
-    @github_commit ||= Shipit.github_api.commit(github_repo_name, sha)
-  end
-
-  def schedule_fetch_stats!
-    FetchCommitStatsJob.perform_later(self)
-  end
-
-  def fetch_stats!
-    update!(
-      additions: github_commit.stats.try!(:additions),
-      deletions: github_commit.stats.try!(:deletions),
-    )
-  end
-
-  def visible_statuses
-    stack.filter_visible_statuses(last_statuses)
-  end
-
-  def meaningful_statuses
-    stack.filter_meaningful_statuses(last_statuses)
-  end
-
-  def last_statuses
-    @last_statuses ||= statuses.to_a.uniq(&:context).sort_by(&:context).presence || [UnknownStatus.new(self)]
-  end
-
-  def status
-    visibles = visible_statuses
-    status = visibles.size > 1 ? StatusGroup.new(significant_status, visibles) : visibles.first
-    missing_statuses.empty? ? status : MissingStatus.new(status, missing_statuses)
-  end
-
-  def significant_status
-    statuses = meaningful_statuses
-    return UnknownStatus.new(self) if statuses.empty?
-    return statuses.first if statuses.all?(&:success?)
-    non_success_statuses = statuses.reject(&:success?)
-    non_success_statuses.reject(&:pending?).first || non_success_statuses.first || UnknownStatus.new(self)
-  end
-
-  private
-
-  def missing_statuses
-    stack.required_statuses - last_statuses.map(&:context)
-  end
-
-  def touch_stack
-    stack.touch
-  end
-
-  def already_deployed?
-    stack.last_deployed_commit.id >= id
-  end
-
-  def simple_state(status)
-    status.state == 'error' ? 'failure' : status.state
-  end
-end