shipit-engine 0.5.2 → 0.6.0

data/app/jobs/shipit/refresh_github_user_job.rb

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

data/app/jobs/shipit/refresh_statuses_job.rb

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

data/app/jobs/shipit/setup_github_hook_job.rb

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

data/app/models/shipit/anonymous_user.rb

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

data/app/models/shipit/api_client.rb

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

data/app/models/shipit/commit.rb

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

data/app/models/shipit/commit_checks.rb

@@ -0,0 +1,90 @@
+module Shipit
+  class CommitChecks
+    OUTPUT_TTL = 10.minutes.to_i
+    FINAL_STATUSES = %w(failed error success)
+
+    def initialize(commit)
+      @commit = commit
+    end
+
+    def run
+      self.status = 'running'
+      commands = StackCommands.new(stack)
+      commands.with_temporary_working_directory(commit: commit) do |directory|
+        deploy_spec = DeploySpec::FileSystem.new(directory, stack.environment)
+        Bundler.with_clean_env do
+          capture_all(build_commands(deploy_spec.dependencies_steps, chdir: directory))
+          capture_all(build_commands(deploy_spec.review_checks, chdir: directory))
+        end
+      end
+    rescue Command::Error
+      self.status = 'failed'
+    rescue
+      self.status = 'error'
+      raise
+    else
+      self.status = 'success'
+    end
+
+    def schedule
+      if redis.set('output', '', ex: OUTPUT_TTL, nx: true)
+        self.status = 'scheduled'
+        PerformCommitChecksJob.perform_later(commit: commit)
+      end
+    end
+
+    def status
+      @status ||= redis.get('status')
+    end
+
+    def status=(status)
+      redis.set('status', status, ex: OUTPUT_TTL)
+      @status = status
+    end
+
+    def finished?
+      FINAL_STATUSES.include?(status)
+    end
+
+    def output(since: 0)
+      redis.getrange('output', since, -1)
+    end
+
+    def write(output)
+      redis.append('output', output)
+    end
+
+    private
+
+    def build_commands(commands, chdir:)
+      commands.map { |c| Command.new(c, env: Shipit.env, chdir: chdir) }
+    end
+
+    def capture_all(commands)
+      commands.map { |c| capture(c) }
+    end
+
+    def capture(command)
+      command.start
+      write("$ #{command}\n")
+      command.stream! do |line|
+        write(line)
+      end
+    rescue Command::Error => error
+      write(error.message)
+      raise
+    ensure
+      write("\n")
+    end
+
+    attr_reader :commit
+
+    def redis
+      @redis ||= Shipit.redis("commit:#{commit.id}:checks")
+    end
+
+    def stack
+      @stack ||= commit.stack
+    end
+  end
+end

data/app/models/shipit/delivery.rb

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