shipit-engine 0.0.1.pre

data/app/jobs/deliver_hook_job.rb

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

data/app/jobs/destroy_stack_job.rb

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

data/app/jobs/emit_event_job.rb

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

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

data/app/jobs/fetch_deployed_revision_job.rb

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

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

@@ -0,0 +1,42 @@
+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])
+
+    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
+
+  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 lookup_commit(sha)
+    @stack.commits.find_by_sha(sha)
+  end
+end

data/app/jobs/perform_task_job.rb

@@ -0,0 +1,53 @@
+class PerformTaskJob < BackgroundJob
+  queue_as :deploys
+
+  def perform(params)
+    @task = Task.find(params[:task_id])
+    unless @task.pending?
+      logger.error("Task ##{@task.id} already in `#{@task.status}` state. Aborting.")
+      return
+    end
+
+    @task.run!
+    commands = Commands.for(@task)
+    @task.acquire_git_cache_lock do
+      capture commands.fetch
+      capture commands.clone
+    end
+    capture commands.checkout(@task.until_commit)
+
+    record_deploy_spec!
+
+    Bundler.with_clean_env do
+      capture_all commands.install_dependencies
+      capture_all commands.perform
+    end
+    @task.complete!
+  rescue Command::Error
+    @task.failure!
+  rescue StandardError => error
+    @task.error!
+    @task.write("#{error.class}: #{error.message}\n\t#{error.backtrace.join("\t")}\n")
+  ensure
+    FetchDeployedRevisionJob.perform_later(@task.stack)
+    @task.clear_working_directory
+  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
+
+  def record_deploy_spec!
+    @task.stack.update(cached_deploy_spec: @task.spec)
+  end
+end

data/app/jobs/refresh_github_user_job.rb

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

data/app/jobs/refresh_statuses_job.rb

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

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

data/app/models/anonymous_user.rb

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

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

@@ -0,0 +1,163 @@
+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 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
+
+  delegate :pending?, :success?, :error?, :failure?, to: :significant_status
+  delegate :state, to: :significant_status # deprecated
+
+  def deployable?
+    success? || stack.ignore_ci?
+  end
+
+  def last_statuses
+    statuses.to_a.uniq(&:context).sort_by(&:context).presence || [UnknownStatus.new(self)]
+  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 && "https://github.com/#{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 newer_commit_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
+
+  private
+
+  def touch_stack
+    stack.touch
+  end
+
+  def significant_status
+    statuses = last_statuses
+    return nil 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
+
+  def newer_commit_deployed?
+    stack.last_deployed_commit.id > id
+  end
+end