shipit-engine 0.5.2 → 0.6.0

data/app/models/shipit/status.rb

@@ -0,0 +1,44 @@
+module Shipit
+  class Status < ActiveRecord::Base
+    STATES = %w(pending success failure error).freeze
+    enum state: STATES.zip(STATES).to_h
+
+    belongs_to :commit, touch: true
+
+    validates :state, inclusion: {in: STATES, allow_blank: true}, presence: true
+
+    after_create :enable_ci_on_stack
+    after_commit :schedule_continuous_delivery, :broadcast_update, on: :create
+    after_commit :touch_commit
+
+    delegate :broadcast_update, to: :commit
+
+    def self.replicate_from_github!(github_status)
+      find_or_create_by!(
+        state: github_status.state,
+        description: github_status.description,
+        target_url: github_status.rels.try(:[], :target).try(:href),
+        context: github_status.context,
+        created_at: github_status.created_at,
+      )
+    end
+
+    def group?
+      false
+    end
+
+    private
+
+    def enable_ci_on_stack
+      commit.stack.enable_ci!
+    end
+
+    def touch_commit
+      commit.touch
+    end
+
+    def schedule_continuous_delivery
+      commit.schedule_continuous_delivery
+    end
+  end
+end

data/app/models/shipit/status_group.rb

@@ -0,0 +1,35 @@
+module Shipit
+  class StatusGroup
+    STATES_PRIORITY = %w(failure error pending success).freeze
+
+    attr_reader :statuses, :significant_status
+
+    def initialize(significant_status, visible_statuses)
+      @significant_status = significant_status
+      @statuses = visible_statuses
+    end
+
+    delegate :success?, :state, to: :significant_status
+
+    def description
+      "#{success_count} / #{statuses.count} checks OK"
+    end
+
+    def target_url
+    end
+
+    def to_partial_path
+      'statuses/group'
+    end
+
+    def group?
+      true
+    end
+
+    private
+
+    def success_count
+      @statuses.count { |s| s.state == 'success'.freeze }
+    end
+  end
+end

data/app/models/shipit/task.rb

@@ -0,0 +1,201 @@
+module Shipit
+  class Task < ActiveRecord::Base
+    belongs_to :deploy, foreign_key: :parent_id, required: false # required for fixtures
+
+    belongs_to :user
+    belongs_to :stack, touch: true, counter_cache: true
+    belongs_to :until_commit, class_name: 'Commit'
+    belongs_to :since_commit, class_name: 'Commit'
+
+    has_many :chunks, -> { order(:id) }, class_name: 'OutputChunk', dependent: :destroy
+
+    serialize :definition, TaskDefinition
+    serialize :env, Hash
+
+    scope :success, -> { where(status: 'success') }
+    scope :completed, -> { where(status: %w(success error failed flapping aborted)) }
+    scope :active, -> { where(status: %w(pending running aborting)) }
+
+    scope :due_for_rollup, -> { completed.where(rolled_up: false).where('created_at <= ?', 1.hour.ago) }
+
+    after_save :record_status_change
+    after_commit :emit_hooks
+
+    state_machine :status, initial: :pending do
+      after_transition any => %i(success failed error) do |task|
+        task.async_refresh_deployed_revision
+      end
+
+      after_transition any => :flapping do |task|
+        task.update!(confirmations: 0)
+      end
+
+      event :run do
+        transition pending: :running
+      end
+
+      event :failure do
+        transition %i(running flapping) => :failed
+      end
+
+      event :complete do
+        transition %i(running flapping) => :success
+      end
+
+      event :error do
+        transition all => :error
+      end
+
+      event :aborting do
+        transition all - %i(aborted) => :aborting
+      end
+
+      event :aborted do
+        transition aborting: :aborted
+      end
+
+      event :flap do
+        transition %i(failed error success) => :flapping
+      end
+
+      state :pending
+      state :running
+      state :failed
+      state :success
+      state :error
+      state :aborting
+      state :aborted
+      state :flapping
+    end
+
+    def report_failure!(_error)
+      reload
+      if aborting?
+        aborted!
+      else
+        failure!
+      end
+    end
+
+    def report_error!(error)
+      write("#{error.class}: #{error.message}\n\t#{error.backtrace.join("\t")}\n")
+      error!
+    end
+
+    delegate :acquire_git_cache_lock, :async_refresh_deployed_revision, to: :stack
+
+    delegate :checklist, to: :definition
+
+    def spec
+      @spec ||= DeploySpec::FileSystem.new(working_directory, stack.environment)
+    end
+
+    def enqueue
+      raise "only persisted jobs can be enqueued" unless persisted?
+      PerformTaskJob.perform_later(self)
+    end
+
+    def write(text)
+      chunks.create!(text: text)
+    end
+
+    def chunk_output
+      if rolled_up?
+        output
+      else
+        chunks.pluck(:text).join
+      end
+    end
+
+    def schedule_rollup_chunks
+      ChunkRollupJob.perform_later(self)
+    end
+
+    def rollup_chunks
+      ActiveRecord::Base.transaction do
+        self.output = chunk_output
+        chunks.delete_all
+        update_attribute(:rolled_up, true)
+      end
+    end
+
+    def output
+      gzip = self[:gzip_output]
+
+      if gzip.nil? || gzip.empty?
+        ''
+      else
+        ActiveSupport::Gzip.decompress(gzip)
+      end
+    end
+
+    def output=(string)
+      self[:gzip_output] = ActiveSupport::Gzip.compress(string)
+    end
+
+    def rollback?
+      false
+    end
+
+    def rollbackable?
+      false
+    end
+
+    def supports_rollback?
+      false
+    end
+
+    def author
+      user || AnonymousUser.new
+    end
+
+    def finished?
+      !pending? && !running? && !aborting?
+    end
+
+    def pid
+      pid = Shipit.redis.get("task:#{id}:pid")
+      pid.presence && pid.to_i
+    end
+
+    def pid=(pid)
+      Shipit.redis.set("task:#{id}:pid", pid, ex: 1.hour.to_i)
+    end
+
+    def abort!(rollback_once_aborted: false)
+      target_pid = pid
+      return write("\nAbort: failed, PID unknown\n") unless target_pid.present?
+
+      update!(rollback_once_aborted: rollback_once_aborted)
+      aborting!
+      write("\nAbort: sending SIGTERM to pid #{target_pid}\n")
+      Process.kill('TERM', target_pid)
+    rescue Errno::ESRCH
+      write("\nAbort: PID #{target_pid} ESRCH: No such process\n")
+      aborted!
+      true
+    end
+
+    def working_directory
+      File.join(stack.deploys_path, id.to_s)
+    end
+
+    def clear_working_directory
+      FileUtils.rm_rf(working_directory)
+    end
+
+    def record_status_change
+      @status_changed ||= status_changed?
+    end
+
+    def emit_hooks
+      return unless @status_changed
+      @status_changed = nil
+      Hook.emit(hook_event, stack, hook_event => self, status: status, stack: stack)
+    end
+
+    def hook_event
+      self.class.name.demodulize.underscore.to_sym
+    end
+  end
+end

data/app/models/shipit/task_definition.rb

@@ -0,0 +1,38 @@
+module Shipit
+  class TaskDefinition
+    NotFound = Class.new(StandardError)
+
+    class << self
+      def load(payload)
+        return unless payload.present?
+        json = JSON.parse(payload)
+        new(json.delete('id'), json)
+      end
+
+      def dump(definition)
+        return unless definition.present?
+        JSON.dump(definition.as_json)
+      end
+    end
+
+    attr_reader :id, :action, :description, :steps, :checklist
+
+    def initialize(id, config)
+      @id = id
+      @action = config['action']
+      @description = config['description'] || ''
+      @steps = config['steps'] || []
+      @checklist = config['checklist'] || []
+    end
+
+    def as_json
+      {
+        id: id,
+        action: action,
+        description: description,
+        steps: steps,
+        checklist: checklist,
+      }
+    end
+  end
+end

data/app/models/shipit/team.rb

@@ -0,0 +1,69 @@
+module Shipit
+  class Team < ActiveRecord::Base
+    REQUIRED_HOOKS = %i(membership)
+
+    has_many :members, class_name: :User, through: :memberships, source: :user
+    has_many :memberships
+
+    has_many :github_hooks,
+      -> { where(event: REQUIRED_HOOKS) },
+      foreign_key: :organization,
+      primary_key: :organization,
+      class_name: 'GithubHook::Organization'
+
+    after_commit :setup_hooks, if: :automatically_setup_hooks?
+
+    class << self
+      def find_or_create_by_handle(handle)
+        organization, slug = handle.split('/').map(&:downcase)
+        find_by(organization: organization, slug: slug) || fetch_and_create_from_github(organization, slug)
+      end
+
+      def fetch_and_create_from_github(organization, slug)
+        if github_team = find_team_on_github(organization, slug)
+          create!(github_team: github_team, organization: organization)
+        end
+      end
+
+      def find_team_on_github(organization, slug)
+        teams = Shipit::OctokitIterator.new { Shipit.github_api.org_teams(organization, per_page: 100) }
+        teams.find { |t| t.slug == slug }
+      rescue Octokit::NotFound
+      end
+    end
+
+    def handle
+      "#{organization}/#{slug}"
+    end
+
+    def add_member(member)
+      members.append(member) unless members.include?(member)
+    end
+
+    attr_writer :automatically_setup_hooks
+    def automatically_setup_hooks?
+      @automatically_setup_hooks
+    end
+
+    def setup_hooks(async: true)
+      REQUIRED_HOOKS.each do |event|
+        hook = github_hooks.find_or_create_by!(event: event)
+        async ? hook.schedule_setup! : hook.setup!
+      end
+    end
+
+    def refresh_members!
+      github_members = Shipit::OctokitIterator.new(Shipit.github_api.get(api_url).rels[:members])
+      members = github_members.map { |u| User.find_or_create_from_github(u) }
+      self.members = members
+      save!
+    end
+
+    def github_team=(github_team)
+      self.name = github_team.name
+      self.slug = github_team.slug
+      self.api_url = github_team.url
+      self.github_id = github_team.id
+    end
+  end
+end

data/app/models/shipit/unknown_status.rb

@@ -0,0 +1,43 @@
+module Shipit
+  UnknownStatus = Struct.new(:commit) do
+    def state
+      'unknown'
+    end
+
+    def pending?
+      false
+    end
+
+    def success?
+      false
+    end
+
+    def error?
+      false
+    end
+
+    def failure?
+      false
+    end
+
+    def group?
+      false
+    end
+
+    def target_url
+      nil
+    end
+
+    def description
+      ''
+    end
+
+    def context
+      'ci/unknown'
+    end
+
+    def to_partial_path
+      'shipit/statuses/status'
+    end
+  end
+end

data/app/models/shipit/user.rb

@@ -0,0 +1,83 @@
+module Shipit
+  class User < ActiveRecord::Base
+    DEFAULT_AVATAR = URI.parse('https://avatars.githubusercontent.com/u/583231?')
+
+    has_many :authored_commits, class_name: :Commit, foreign_key: :author_id, inverse_of: :author
+    has_many :commits, foreign_key: :committer_id, inverse_of: :committer
+    has_many :tasks
+
+    def self.find_or_create_by_login!(login)
+      find_or_create_by!(login: login) do |user|
+        user.github_user = Shipit.github_api.user(login)
+      end
+    end
+
+    def self.find_or_create_from_github(github_user)
+      find_from_github(github_user) || create_from_github!(github_user)
+    end
+
+    def self.find_from_github(github_user)
+      return unless github_user.id
+      find_by(github_id: github_user.id)
+    end
+
+    def self.create_from_github!(github_user)
+      create!(github_user: github_user)
+    end
+
+    def self.refresh_shard(shard_index, shards_count)
+      where.not(login: nil).where('id % ? = ?', shards_count, shard_index).find_each do |user|
+        RefreshGithubUserJob.perform_later(user)
+      end
+    end
+
+    def identifiers_for_ping
+      {github_id: github_id, name: name, email: email, github_login: login}
+    end
+
+    def logged_in?
+      true
+    end
+
+    def stacks_contributed_to
+      return [] unless id
+      Commit.where('author_id = :id or committer_id = :id', id: id).uniq.pluck(:stack_id)
+    end
+
+    def refresh_from_github!
+      update!(github_user: Shipit.github_api.user(login))
+    rescue Octokit::NotFound
+      identify_renamed_user!
+    end
+
+    def github_user=(github_user)
+      return unless github_user
+      github_user = github_user.rels[:self].get.data unless github_user.name
+      assign_attributes(
+        github_id: github_user.id,
+        name: github_user.name || github_user.login, # Name is not mandatory on GitHub
+        email: github_user.email,
+        login: github_user.login,
+        avatar_url: github_user.rels[:avatar].try(:href),
+        api_url: github_user.rels[:self].try(:href),
+      )
+    end
+
+    def avatar_uri
+      URI.parse(avatar_url)
+    rescue URI::InvalidURIError
+      DEFAULT_AVATAR.dup
+    end
+
+    private
+
+    def identify_renamed_user!
+      last_commit = commits.last
+      return unless last_commit
+      github_author = last_commit.github_commit.author
+      update!(github_user: github_author)
+    rescue Octokit::NotFound
+      false
+    end
+  end
+end