shipit-engine 0.5.2 → 0.6.0

data/app/models/stack.rb

@@ -1,306 +0,0 @@
-require 'fileutils'
-
-class Stack < ActiveRecord::Base
-  REPO_OWNER_MAX_SIZE = 39
-  REPO_NAME_MAX_SIZE = 100
-  ENVIRONMENT_MAX_SIZE = 50
-  REQUIRED_HOOKS = %i(push status)
-
-  has_many :commits, dependent: :destroy
-  has_many :tasks, dependent: :destroy
-  has_many :deploys
-  has_many :rollbacks
-  has_many :deploys_and_rollbacks, -> { where(type: %w(Deploy Rollback)) }, class_name: 'Task'
-  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
-
-  def lock_author(*)
-    super || AnonymousUser.new
-  end
-
-  def lock_author=(user)
-    super(user.try!(:logged_in?) ? user : nil)
-  end
-
-  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, :environment, presence: true, ascii_only: true
-  validates :repo_owner, format: {with: /\A[a-z0-9_\-\.]+\z/}, length: {maximum: REPO_OWNER_MAX_SIZE}
-  validates :repo_name, format: {with: /\A[a-z0-9_\-\.]+\z/}, length: {maximum: REPO_NAME_MAX_SIZE}
-  validates :environment, format: {with: /\A[a-z0-9\-_\:]+\z/}, length: {maximum: ENVIRONMENT_MAX_SIZE}
-
-  validates :lock_reason, length: {maximum: 4096}
-
-  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, env: nil)
-    since_commit = last_deployed_commit
-
-    deploy = deploys.create(
-      user_id: user.id,
-      until_commit: until_commit,
-      since_commit: since_commit,
-      env: env || {},
-    )
-    deploy.enqueue
-    deploy
-  end
-
-  def async_refresh_deployed_revision
-    FetchDeployedRevisionJob.perform_later(self)
-  end
-
-  def update_deployed_revision(sha)
-    return if deploying?
-
-    last_deploy = deploys_and_rollbacks.last
-    actual_deployed_commit = commits.reachable.by_sha!(sha)
-
-    if last_deploy && actual_deployed_commit == last_deploy.until_commit
-      last_deploy.accept!
-    elsif last_deploy && actual_deployed_commit == last_deploy.since_commit
-      last_deploy.reject!
-    else
-      deploys.create!(
-        until_commit: actual_deployed_commit,
-        since_commit: last_deployed_commit,
-        status: 'success',
-      )
-    end
-  end
-
-  def head
-    commits.reachable.first.try!(:sha)
-  end
-
-  def status
-    return :deploying if deploying?
-    :default
-  end
-
-  def last_successful_deploy
-    deploys_and_rollbacks.success.order(created_at: :desc).first
-  end
-
-  def last_deployed_commit
-    if deploy = last_successful_deploy
-      deploy.until_commit
-    else
-      commits.first
-    end
-  end
-
-  def filter_visible_statuses(statuses)
-    statuses.reject { |s| hidden_statuses.include?(s.context) }
-  end
-
-  def filter_meaningful_statuses(statuses)
-    filter_visible_statuses(statuses).reject { |s| soft_failing_statuses.include?(s.context) }
-  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
-    Shipit.github_url("#{repo_owner}/#{repo_name}")
-  end
-
-  def repo_git_url
-    "git@#{Shipit.github_domain}:#{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_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_and_rollbacks.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
-
-  delegate :plugins, :task_definitions, :hidden_statuses, :required_statuses, :soft_failing_statuses,
-           :deploy_variables, to: :cached_deploy_spec
-
-  def monitoring?
-    monitoring.present?
-  end
-
-  def monitoring
-    cached_deploy_spec.review_monitoring
-  end
-
-  def checklist
-    cached_deploy_spec.review_checklist
-  end
-
-  def checks?
-    cached_deploy_spec.review_checks.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
-
-  def mark_as_accessible!
-    update!(inaccessible_since: nil)
-  end
-
-  def mark_as_inaccessible!
-    update!(inaccessible_since: Time.now) unless inaccessible?
-  end
-
-  def inaccessible?
-    inaccessible_since?
-  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

data/app/models/status.rb

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

data/app/models/status_group.rb

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

data/app/models/task.rb

@@ -1,197 +0,0 @@
-class Task < ActiveRecord::Base
-  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.underscore.to_sym
-  end
-end