shipit-engine 0.5.2 → 0.6.0

data/app/controllers/api/base_controller.rb

@@ -1,66 +0,0 @@
-module Api
-  class BaseController < ActionController::Base
-    include Shipit::Engine.routes.url_helpers
-    include Rendering
-    include Cacheable
-    include Paginable
-
-    rescue_from ApiClient::InsufficientPermission, with: :insufficient_permission
-    rescue_from TaskDefinition::NotFound, with: :not_found
-
-    class << self
-      def require_permission(operation, scope, options = {})
-        before_action(options) { require_permission!(operation, scope) }
-      end
-    end
-
-    before_action :authenticate_api_client
-
-    def index
-      render json: {stacks_url: api_stacks_url}
-    end
-
-    private
-
-    def authenticate_api_client
-      @current_api_client = authenticate_with_http_basic do |*parts|
-        token = parts.select(&:present?).join('--')
-        ApiClient.authenticate(token)
-      end
-      return if @current_api_client
-      headers['WWW-Authenticate'] = 'Basic realm="Authentication token"'
-      render status: :unauthorized, json: {message: 'Bad credentials'}
-    end
-
-    attr_reader :current_api_client
-
-    def current_user
-      @current_user ||= identify_user || AnonymousUser.new
-    end
-
-    def identify_user
-      user_login = request.headers['X-Shipit-User'].presence
-      User.find_by(login: user_login) if user_login
-    end
-
-    def stacks
-      @stacks ||= current_api_client.stack_id? ? Stack.where(id: current_api_client.stack_id) : Stack.all
-    end
-
-    def stack
-      @stack ||= stacks.from_param!(params[:stack_id])
-    end
-
-    def require_permission!(operation, scope)
-      current_api_client.check_permissions!(operation, scope)
-    end
-
-    def insufficient_permission(error)
-      render status: :forbidden, json: {message: error.message}
-    end
-
-    def not_found(_error)
-      render status: :not_found, json: {status: '404', error: 'Not Found'}
-    end
-  end
-end

data/app/controllers/api/deploys_controller.rb

@@ -1,15 +0,0 @@
-module Api
-  class DeploysController < BaseController
-    require_permission :deploy, :stack
-
-    params do
-      requires :sha, String, length: {in: 6..40}
-      accepts :force, Boolean, default: false
-    end
-    def create
-      commit = stack.commits.by_sha(params.sha) || param_error!(:sha, 'Unknown revision')
-      param_error!(:force, "Can't deploy a locked stack") if !params.force && stack.locked?
-      render_resource stack.trigger_deploy(commit, current_user), status: :accepted
-    end
-  end
-end

data/app/controllers/api/hooks_controller.rb

@@ -1,51 +0,0 @@
-module Api
-  class HooksController < BaseController
-    require_permission :read, :hook, only: %i(index show)
-    require_permission :write, :hook, only: %i(create update destroy)
-
-    def index
-      render_resources hooks
-    end
-
-    def show
-      render json: hook
-    end
-
-    params do
-      requires :url, String
-      requires :events, Array[String]
-      accepts :content_type, String
-    end
-    def create
-      render_resource hooks.create(params)
-    end
-
-    params do
-      accepts :url, String
-      accepts :events, Array[String]
-      accepts :content_type, String
-    end
-    def update
-      hook.update(params)
-      render_resource hook
-    end
-
-    def destroy
-      render_resource hook.destroy
-    end
-
-    private
-
-    def hook
-      hooks.find(params[:id])
-    end
-
-    def hooks
-      Hook.where(stack_id: stack_id)
-    end
-
-    def stack_id
-      stack.id if params[:stack_id].present?
-    end
-  end
-end

data/app/controllers/api/locks_controller.rb

@@ -1,30 +0,0 @@
-module Api
-  class LocksController < BaseController
-    require_permission :lock, :stack
-
-    params do
-      requires :reason, String, presence: true
-    end
-    def create
-      if stack.locked?
-        render json: {message: 'Already locked'}, status: :conflict
-      else
-        stack.update(lock_reason: params.reason, lock_author: current_user)
-        render_resource stack
-      end
-    end
-
-    params do
-      requires :reason, String, presence: true
-    end
-    def update
-      stack.update(lock_reason: params.reason, lock_author: current_user)
-      render_resource stack
-    end
-
-    def destroy
-      stack.update(lock_reason: nil, lock_author: nil)
-      render_resource stack
-    end
-  end
-end

data/app/controllers/api/outputs_controller.rb

@@ -1,15 +0,0 @@
-module Api
-  class OutputsController < BaseController
-    require_permission :read, :stack
-
-    def show
-      render plain: task.chunk_output
-    end
-
-    private
-
-    def task
-      @task ||= stack.tasks.find(params[:task_id])
-    end
-  end
-end

data/app/controllers/api/stacks_controller.rb

@@ -1,19 +0,0 @@
-module Api
-  class StacksController < BaseController
-    require_permission :read, :stack
-
-    def index
-      render_resources stacks
-    end
-
-    def show
-      render_resource stack
-    end
-
-    private
-
-    def stack
-      @stack ||= stacks.from_param!(params[:id])
-    end
-  end
-end

data/app/controllers/api/tasks_controller.rb

@@ -1,18 +0,0 @@
-module Api
-  class TasksController < BaseController
-    require_permission :read, :stack
-    require_permission :deploy, :stack, only: :trigger
-
-    def index
-      render_resources stack.tasks
-    end
-
-    def show
-      render_resource stack.tasks.find(params[:id])
-    end
-
-    def trigger
-      render_resource stack.trigger_task(params[:task_name], current_user), status: :accepted
-    end
-  end
-end

data/app/controllers/commit_checks_controller.rb

@@ -1,24 +0,0 @@
-class CommitChecksController < ShipitController
-  params do
-    accepts :since, Integer, default: 0
-  end
-  def tail
-    output = checks.output(since: params.since)
-    next_offset = params.since + output.bytesize
-    url = stack_tail_commit_checks_path(stack, sha: commit.sha, since: next_offset) unless checks.finished?
-
-    render json: {url: url, output: output, status: checks.status}
-  end
-
-  private
-
-  delegate :checks, to: :commit
-
-  def commit
-    @commit ||= stack.commits.find_by_sha!(params[:sha])
-  end
-
-  def stack
-    @stack ||= Stack.from_param!(params[:stack_id])
-  end
-end

data/app/controllers/concerns/api/cacheable.rb

@@ -1,11 +0,0 @@
-module Api
-  module Cacheable
-    def render_resources(resources, *)
-      super if stale?(etag: resources, last_modified: resources.map(&:updated_at).max, template: false)
-    end
-
-    def render_resource(resource, *)
-      super if stale?(etag: resource, last_modified: resource.updated_at, template: false)
-    end
-  end
-end

data/app/controllers/concerns/api/rendering.rb

@@ -1,23 +0,0 @@
-module Api
-  module Rendering
-    private
-
-    def render_resources(resources, options = {})
-      options[:json] = resources
-      render options
-    end
-
-    def render_resource(resource, options = {})
-      if resource.destroyed?
-        options[:status] = :no_content
-        options[:text] = nil
-      elsif resource.errors.any?
-        options[:json] = {errors: resource.errors}
-        options[:status] = :unprocessable_entity
-      else
-        options[:json] = resource
-      end
-      render options
-    end
-  end
-end

data/app/controllers/concerns/pagination.rb

@@ -1,25 +0,0 @@
-module Pagination
-  extend ActiveSupport::Concern
-
-  included do
-    class_attribute :max_page_size
-    class_attribute :default_page_size
-    class_attribute :default_order
-
-    self.max_page_size = 100
-    self.default_page_size = 30
-    self.default_order = {id: :desc}.freeze
-  end
-
-  private
-
-  def paginate(relation)
-    Shipit::Paginator.new(
-      relation,
-      self,
-      order: default_order,
-      max_page_size: max_page_size,
-      default_page_size: default_page_size,
-    )
-  end
-end

data/app/controllers/deploys_controller.rb

@@ -1,45 +0,0 @@
-class DeploysController < ShipitController
-  include ChunksHelper
-
-  before_action :load_stack
-  before_action :load_deploy, only: %i(show rollback)
-  before_action :load_until_commit, only: :create
-
-  def new
-    @commit = @stack.commits.by_sha!(params[:sha])
-    @commit.checks.schedule if @stack.checks?
-    @deploy = @stack.deploys.new(until_commit: @commit, since_commit: @stack.last_deployed_commit)
-  end
-
-  def show
-  end
-
-  def create
-    return redirect_to new_stack_deploy_path(@stack, sha: @until_commit.sha) if !params[:force] && @stack.deploying?
-
-    @deploy = @stack.trigger_deploy(@until_commit, current_user, env: deploy_params[:env])
-    respond_with(@deploy.stack, @deploy)
-  end
-
-  def rollback
-    @rollback = @deploy.build_rollback
-  end
-
-  private
-
-  def load_deploy
-    @deploy = @stack.deploys.find(params[:id])
-  end
-
-  def load_stack
-    @stack ||= Stack.from_param!(params[:stack_id])
-  end
-
-  def load_until_commit
-    @until_commit = @stack.commits.find(deploy_params[:until_commit_id])
-  end
-
-  def deploy_params
-    @deploy_params ||= params.require(:deploy).permit(:until_commit_id, env: @stack.deploy_variables.map(&:name))
-  end
-end

data/app/controllers/github_authentication_controller.rb

@@ -1,25 +0,0 @@
-class GithubAuthenticationController < ActionController::Base
-  include Shipit::Engine.routes.url_helpers
-
-  def callback
-    return_url = request.env['omniauth.origin'] || root_path
-    auth = request.env['omniauth.auth']
-
-    return render 'failed', layout: false if auth.blank?
-
-    session[:user_id] = sign_in_github(auth)
-    redirect_to return_url
-  end
-
-  def logout
-    reset_session
-    redirect_to root_path
-  end
-
-  private
-
-  def sign_in_github(auth)
-    user = Shipit.github_api.user(auth[:info][:nickname])
-    User.find_or_create_from_github(user).id
-  end
-end

data/app/controllers/rollbacks_controller.rb

@@ -1,24 +0,0 @@
-class RollbacksController < ShipitController
-  before_action :load_stack
-  before_action :load_deploy
-
-  def create
-    return redirect_to rollback_stack_deploy_path(@stack, @deploy) if !params[:force] && @stack.deploying?
-    @rollback = @deploy.trigger_rollback(current_user, env: rollback_params[:env])
-    redirect_to stack_deploy_path(@stack, @rollback)
-  end
-
-  private
-
-  def load_stack
-    @stack ||= Stack.from_param!(params[:stack_id])
-  end
-
-  def load_deploy
-    @deploy = @stack.deploys.find(rollback_params[:parent_id])
-  end
-
-  def rollback_params
-    params.require(:rollback).permit(:parent_id, env: @stack.deploy_variables.map(&:name))
-  end
-end

data/app/controllers/shipit_controller.rb

@@ -1,54 +0,0 @@
-class ShipitController < ApplicationController
-  layout 'shipit'
-
-  helper Shipit::Engine.routes.url_helpers
-  include Shipit::Engine.routes.url_helpers
-
-  before_action :ensure_required_settings,
-                :force_github_authentication,
-                :set_variant
-
-  # Respond to HTML by default
-  respond_to :html
-
-  # Prevent CSRF attacks by raising an exception.
-  # For APIs, you may want to use :null_session instead.
-  protect_from_forgery with: :exception
-
-  private
-
-  def ensure_required_settings
-    return if Shipit.all_settings_present?
-
-    render 'missing_settings'
-  end
-
-  def force_github_authentication
-    if current_user.logged_in?
-      team = Shipit.github_team
-      if team && !current_user.in?(team.members)
-        render text: "You must be a member of #{team.handle} to access this application.", status: :forbidden
-      end
-    else
-      redirect_to Shipit::Engine.routes.url_helpers.github_authentication_path(origin: request.original_url)
-    end
-  end
-
-  def current_user
-    @current_user ||= find_current_user || AnonymousUser.new
-  end
-  helper_method :current_user
-
-  def find_current_user
-    return unless session[:user_id].present?
-    User.find(session[:user_id])
-  rescue ActiveRecord::RecordNotFound
-  end
-
-  def set_variant
-    return unless request.negotiate_mime('text/partial+html')
-
-    request.format = :html
-    request.variant = :partial
-  end
-end