shipit-engine 0.5.2 → 0.6.0

data/app/models/task_definition.rb

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

data/app/models/team.rb

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

data/app/models/unknown_status.rb

@@ -1,41 +0,0 @@
-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
-    'statuses/status'
-  end
-end

data/app/models/user.rb

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

data/app/models/variable_definition.rb

@@ -1,19 +0,0 @@
-class VariableDefinition
-  attr_reader :name, :title, :value, :default
-
-  def initialize(attributes)
-    @name = attributes.fetch('name')
-    @title = attributes['title']
-    @value = attributes['value']
-    @default = attributes['default']
-  end
-
-  def to_h
-    {
-      'name' => @name,
-      'title' => @title,
-      'value' => @value,
-      'default' => @default,
-    }
-  end
-end

data/app/serializers/anonymous_user_serializer.rb

@@ -1,2 +0,0 @@
-class AnonymousUserSerializer < UserSerializer
-end

data/app/serializers/commit_serializer.rb

@@ -1,6 +0,0 @@
-class CommitSerializer < ShortCommitSerializer
-  has_one :author
-  has_one :committer
-
-  attributes :additions, :deletions, :authored_at, :committed_at
-end

data/app/serializers/concerns/conditional_attributes.rb

@@ -1,20 +0,0 @@
-module ConditionalAttributes
-  extend ActiveSupport::Concern
-
-  module ClassMethods
-    def inclusion_method_for(attribute)
-      @inclusion_cache ||= {}
-      @inclusion_cache.fetch(attribute) do
-        method = "include_#{attribute}?"
-        method_defined?(method) && method
-      end
-    end
-  end
-
-  def filter(*)
-    super.reject do |attribute|
-      method = self.class.inclusion_method_for(attribute)
-      method && !send(method)
-    end
-  end
-end

data/app/serializers/deploy_serializer.rb

@@ -1,13 +0,0 @@
-class DeploySerializer < TaskSerializer
-  has_many :commits
-
-  attributes :additions, :deletions
-
-  def html_url
-    stack_deploy_url(object.stack, object)
-  end
-
-  def type
-    :deploy
-  end
-end

data/app/serializers/hook_serializer.rb

@@ -1,10 +0,0 @@
-class HookSerializer < ActiveModel::Serializer
-  include ConditionalAttributes
-
-  has_one :stack
-  attributes :id, :url, :content_type, :events, :insecure_ssl, :created_at, :updated_at
-
-  def include_stack?
-    object.scoped?
-  end
-end

data/app/serializers/rollback_serializer.rb

@@ -1,5 +0,0 @@
-class RollbackSerializer < DeploySerializer
-  def type
-    :rollback
-  end
-end

data/app/serializers/short_commit_serializer.rb

@@ -1,7 +0,0 @@
-class ShortCommitSerializer < ActiveModel::Serializer
-  attributes :sha, :message
-
-  def message
-    object.pull_request? ? "#{object.pull_request_title} (##{object.pull_request_id})" : object.message
-  end
-end

data/app/serializers/stack_serializer.rb

@@ -1,31 +0,0 @@
-class StackSerializer < ActiveModel::Serializer
-  include ConditionalAttributes
-
-  has_one :lock_author
-  attributes :id, :repo_owner, :repo_name, :environment, :html_url, :url, :tasks_url,
-             :undeployed_commits_count, :is_locked, :lock_reason, :continuous_deployment, :created_at, :updated_at
-
-  def url
-    api_stack_url(object)
-  end
-
-  def html_url
-    stack_url(object)
-  end
-
-  def tasks_url
-    api_stack_tasks_url(object)
-  end
-
-  def is_locked
-    object.locked?
-  end
-
-  def include_lock_reason?
-    object.locked?
-  end
-
-  def include_lock_author?
-    object.locked?
-  end
-end

data/app/serializers/tail_task_serializer.rb

@@ -1,37 +0,0 @@
-class TailTaskSerializer < ActiveModel::Serializer
-  include ChunksHelper
-  include ConditionalAttributes
-
-  attributes :url, :status, :output, :rollback_url
-
-  def url
-    return @url if defined? @url
-    @url = next_chunks_url(task)
-  end
-
-  def include_url?
-    !url.blank?
-  end
-
-  def output
-    task.chunks.tail(context[:last_id]).pluck(:text).join
-  end
-
-  def rollback_url
-    stack_deploy_path(stack, rollback)
-  end
-
-  def include_rollback_url?
-    !rollback.nil?
-  end
-
-  private
-
-  alias_method :task, :object
-  delegate :stack, to: :object
-
-  def rollback
-    return @rollback if defined? @rollback
-    @rollback = stack.rollbacks.where(parent_id: task.id).last
-  end
-end

data/app/serializers/task_serializer.rb

@@ -1,28 +0,0 @@
-class TaskSerializer < ActiveModel::Serializer
-  include ConditionalAttributes
-
-  has_one :author
-  has_one :revision, serializer: ShortCommitSerializer
-
-  attributes :id, :url, :html_url, :output_url, :type, :status, :updated_at, :created_at
-
-  def revision
-    object.until_commit
-  end
-
-  def url
-    api_stack_task_url(object.stack, object)
-  end
-
-  def html_url
-    stack_task_url(object.stack, object)
-  end
-
-  def output_url
-    api_stack_task_output_url(object.stack, object)
-  end
-
-  def type
-    :task
-  end
-end

data/app/serializers/user_serializer.rb

@@ -1,3 +0,0 @@
-class UserSerializer < ActiveModel::Serializer
-  attributes :id, :name, :email, :login, :avatar_url, :created_at, :updated_at
-end

data/lib/command.rb

@@ -1,169 +0,0 @@
-require 'pty'
-require 'shellwords'
-require 'fileutils'
-require 'timeout'
-
-class Command
-  MAX_READ = 64.kilobytes
-
-  Error = Class.new(StandardError)
-
-  attr_reader :out, :code, :chdir, :env, :args, :pid, :timeout
-
-  def initialize(*args, default_timeout: 5.minutes.to_i, env: {}, chdir:)
-    @args, options = parse_arguments(args)
-    @timeout = options['timeout'.freeze] || options[:timeout] || default_timeout
-    @env = env
-    @chdir = chdir.to_s
-  end
-
-  def to_s
-    @args.join(' ')
-  end
-
-  def interpolate_environment_variables(argument)
-    return argument.map { |a| interpolate_environment_variables(a) } if argument.is_a?(Array)
-
-    argument.gsub(/(\$\w+)/) do |variable|
-      variable.sub!('$', '')
-      Shellwords.escape(@env.fetch(variable) { ENV[variable] })
-    end
-  end
-
-  def success?
-    code == 0
-  end
-
-  def exit_message
-    "#{self} exited with status #{@code}"
-  end
-
-  def run
-    output = []
-    stream do |out|
-      output << out
-    end
-    output.join
-  end
-
-  def run!
-    output = []
-    stream! do |out|
-      output << out
-    end
-    output.join
-  end
-
-  def with_full_path
-    old_path = ENV['PATH']
-    ENV['PATH'] = "#{ENV['PATH']}:#{Shipit::Engine.root.join('lib', 'snippets')}"
-    yield
-  ensure
-    ENV['PATH'] = old_path
-  end
-
-  def interpolated_arguments
-    interpolate_environment_variables(@args)
-  end
-
-  def start
-    return if @started
-    child_in = @out = @pid = nil
-    FileUtils.mkdir_p(@chdir)
-    with_full_path do
-      @out, child_in, @pid = PTY.spawn(@env, *interpolated_arguments, chdir: @chdir)
-      child_in.close
-    end
-    @started = true
-    self
-  end
-
-  def stream(&block)
-    start
-    begin
-      read_stream(@out, &block)
-    rescue Timeout::Error => error
-      @code = 'timeout'
-      yield red("No output received in the last #{timeout} seconds.") + "\n"
-      terminate!(&block)
-      raise error
-    rescue Errno::EIO # Somewhat expected on Linux: http://stackoverflow.com/a/10306782
-    end
-
-    _, status = Process.waitpid2(@pid)
-    @code = status.exitstatus
-    yield exit_message + "\n" unless success?
-
-    self
-  end
-
-  def check_status
-  end
-
-  def red(text)
-    "\033[1;31m#{text}\033[0m"
-  end
-
-  def stream!(&block)
-    stream(&block)
-    raise Command::Error.new(exit_message) unless success?
-    self
-  end
-
-  def read_stream(io)
-    loop do
-      with_timeout do
-        yield io.readpartial(MAX_READ)
-      end
-    end
-  rescue EOFError
-  end
-
-  def with_timeout(&block)
-    return yield unless timeout
-
-    Timeout.timeout(timeout, &block)
-  end
-
-  def terminate!(&block)
-    kill_and_wait('INT', 5, &block)
-    kill_and_wait('INT', 2, &block)
-    kill_and_wait('TERM', 5, &block)
-    kill_and_wait('TERM', 2, &block)
-    kill('KILL', &block)
-  rescue Errno::ECHILD
-    true # much success
-  ensure
-    begin
-      read_stream(@out, &block)
-    rescue
-    end
-  end
-
-  def kill_and_wait(sig, wait, &block)
-    kill(sig, &block)
-    Timeout.timeout(wait) do
-      read_stream(@out, &block)
-    end
-  rescue Timeout::Error
-  end
-
-  def kill(sig)
-    yield red("Sending SIG#{sig} to PID #{@pid}\n")
-    Process.kill(sig, @pid)
-  end
-
-  def parse_arguments(arguments)
-    options = {}
-    args = arguments.flatten.map do |argument|
-      case argument
-      when Hash
-        options.merge!(argument.values.first)
-        argument.keys.first
-      else
-        argument
-      end
-    end
-    return args, options
-  end
-end