shipit-engine 0.5.2 → 0.6.0

data/app/controllers/shipit/github_authentication_controller.rb

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

data/app/controllers/shipit/rollbacks_controller.rb

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

data/app/controllers/shipit/shipit_controller.rb

@@ -0,0 +1,62 @@
+module Shipit
+  class ShipitController < ApplicationController
+    layout 'shipit'
+
+    helper GithubUrlHelper
+    helper StacksHelper
+    helper TasksHelper
+    helper DeploysHelper
+    helper ChunksHelper
+
+    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 'shipit/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
+end

data/app/controllers/shipit/stacks_controller.rb

@@ -0,0 +1,81 @@
+module Shipit
+  class StacksController < ShipitController
+    before_action :load_stack, only: %i(update destroy settings sync_webhooks clear_git_cache refresh)
+
+    def new
+      @stack = Stack.new
+    end
+
+    def index
+      @user_stacks = current_user.stacks_contributed_to
+
+      @stacks = Stack.order('(undeployed_commits_count > 0) desc', tasks_count: :desc).to_a
+    end
+
+    def show
+      @stack = Stack.from_param!(params[:id])
+      return if flash.empty? && !stale?(last_modified: @stack.updated_at)
+
+      @tasks = @stack.tasks.order(id: :desc).preload(:since_commit, :until_commit, :user).limit(10)
+      @commits = @stack.commits.reachable.preload(:author, :statuses).order(id: :desc)
+      if deployed_commit = @stack.last_deployed_commit
+        @commits = @commits.where('id > ?', deployed_commit.id)
+      end
+      @commits = @commits.to_a
+    end
+
+    def create
+      @stack = Stack.create(create_params)
+      respond_with(@stack)
+    end
+
+    def destroy
+      @stack.schedule_for_destroy!
+      redirect_to stacks_url
+    end
+
+    def settings
+    end
+
+    def refresh
+      RefreshStatusesJob.perform_later(stack_id: @stack.id)
+      GithubSyncJob.perform_later(stack_id: @stack.id)
+      flash[:success] = 'Refresh scheduled'
+      redirect_to :back
+    end
+
+    def update
+      options = {}
+      unless @stack.update(update_params)
+        options = {flash: {warning: @stack.errors.full_messages.to_sentence}}
+      end
+      redirect_to(params[:return_to].presence || stack_settings_path(@stack), options)
+    end
+
+    def sync_webhooks
+      @stack.setup_hooks
+      redirect_to stack_settings_path(@stack)
+    end
+
+    def clear_git_cache
+      ClearGitCacheJob.perform_later(@stack)
+      redirect_to stack_settings_path(@stack)
+    end
+
+    private
+
+    def load_stack
+      @stack = Stack.from_param!(params[:id])
+    end
+
+    def create_params
+      params.require(:stack).permit(:repo_name, :repo_owner, :environment, :branch, :deploy_url, :ignore_ci)
+    end
+
+    def update_params
+      params.require(:stack).permit(:deploy_url, :lock_reason, :continuous_deployment, :ignore_ci).tap do |params|
+        params[:lock_author_id] = params[:lock_reason].present? ? current_user.id : nil
+      end
+    end
+  end
+end

data/app/controllers/shipit/status_controller.rb

@@ -0,0 +1,7 @@
+module Shipit
+  class StatusController < ActionController::Base
+    def version
+      render text: Shipit.revision
+    end
+  end
+end

data/app/controllers/shipit/tasks_controller.rb

@@ -0,0 +1,48 @@
+module Shipit
+  class TasksController < ShipitController
+    include Pagination
+
+    before_action :stack
+
+    self.default_page_size = 20
+
+    def index
+      paginator = paginate(stack.tasks)
+      @tasks = paginator.to_a
+      @links = paginator.links
+    end
+
+    def new
+      @definition = stack.find_task_definition(params[:definition_id])
+      @task = stack.tasks.build(definition: @definition)
+    end
+
+    def show
+      task
+    end
+
+    def create
+      @task = stack.trigger_task(params[:definition_id], current_user)
+      redirect_to [stack, @task]
+    end
+
+    def abort
+      task.abort!(rollback_once_aborted: params[:rollback].present?)
+      head :ok
+    end
+
+    def tail
+      render json: TailTaskSerializer.new(task, context: params)
+    end
+
+    private
+
+    def task
+      @task ||= stack.tasks.find(params[:id])
+    end
+
+    def stack
+      @stack ||= Stack.from_param!(params[:stack_id])
+    end
+  end
+end

data/app/controllers/shipit/webhooks_controller.rb

@@ -0,0 +1,101 @@
+module Shipit
+  class WebhooksController < ActionController::Base
+    before_action :check_if_ping, :verify_signature
+
+    respond_to :json
+
+    def push
+      branch = params['ref'].gsub('refs/heads/', '')
+
+      if branch == stack.branch
+        GithubSyncJob.perform_later(stack_id: stack.id)
+        GitMirrorUpdateJob.perform_later(stack)
+      end
+
+      head :ok
+    end
+
+    def state
+      branches = params[:branches] || []
+      if branches.find { |branch| branch[:name] == stack.branch }
+        commit = stack.commits.find_by_sha!(params[:sha])
+        commit.add_status(params.permit(:state, :description, :target_url, :context, :created_at))
+      end
+      head :ok
+    end
+
+    params do
+      requires :team do
+        requires :id, Integer
+        requires :name, String
+        requires :slug, String
+        requires :url, String
+      end
+      requires :organization do
+        requires :login, String
+      end
+      requires :member do
+        requires :login, String
+      end
+    end
+    def membership
+      team = find_or_create_team!
+      member = User.find_or_create_by_login!(params.member.login)
+
+      case membership_action
+      when 'added'
+        team.add_member(member)
+      when 'removed'
+        team.members.delete(member)
+      else
+        raise ArgumentError, "Don't know how to perform action: `#{params.action.inspect}`"
+      end
+      head :ok
+    end
+
+    def index
+      render text: "working"
+    end
+
+    private
+
+    def find_or_create_team!
+      Team.find_or_create_by!(github_id: params.team.id) do |team|
+        team.github_team = params.team
+        team.organization = params.organization.login
+        team.automatically_setup_hooks = true
+      end
+    end
+
+    def verify_signature
+      request.body.rewind
+      head(422) unless webhook.verify_signature(request.headers['X-Hub-Signature'], request.body.read)
+    end
+
+    def check_if_ping
+      head :ok if event == 'ping'
+    end
+
+    def webhook
+      @webhook ||= if params[:stack_id]
+        stack.github_hooks.find_by!(event: event)
+      else
+        GithubHook::Organization.find_by!(organization: params.organization.login, event: event)
+      end
+    end
+
+    def event
+      request.headers['X-Github-Event'] || action_name
+    end
+
+    def membership_action
+      # GitHub send an `action` parameter that is shadowed by Rails url parameters
+      # It's also impossible to pass an `action` parameters from a test case.
+      request.request_parameters['action'] || params[:_action]
+    end
+
+    def stack
+      @stack ||= Stack.find(params[:stack_id])
+    end
+  end
+end

data/app/helpers/shipit/chunks_helper.rb

@@ -0,0 +1,8 @@
+module Shipit
+  module ChunksHelper
+    def next_chunks_url(task)
+      return if task.finished?
+      tail_stack_task_path(task.stack, task, last_id: task.chunks.last)
+    end
+  end
+end

data/app/helpers/shipit/deploys_helper.rb

@@ -0,0 +1,28 @@
+module Shipit
+  module DeploysHelper
+    def render_checklist(checklist)
+      return if checklist.blank?
+      render 'shipit/deploys/checklist', checklist: checklist
+    end
+
+    def render_monitoring(stack)
+      return unless stack.monitoring?
+      render 'shipit/deploys/monitoring', stack: stack
+    end
+
+    def render_checks(commit)
+      return unless commit.stack.checks?
+      render 'shipit/deploys/checks', commit: commit
+    end
+
+    def render_monitoring_panel(panel_spec)
+      if url = panel_spec['image']
+        image_tag(url, panel_spec.slice('height', 'width', 'alt'))
+      elsif url = panel_spec['iframe']
+        content_tag(:iframe, '', panel_spec.slice('height', 'width').merge('src' => url))
+      else
+        content_tag(:span, "#{panel_spec.inspect} is not a valid monitoring panel spec")
+      end
+    end
+  end
+end

data/app/helpers/shipit/github_url_helper.rb

@@ -0,0 +1,48 @@
+module Shipit
+  module GithubUrlHelper
+    def github_avatar(user, options = {})
+      uri = user.avatar_uri
+      attributes = options.slice(:class).merge(alt: user.try!(:name))
+      if options[:size]
+        uri.query ||= ''
+        uri.query += "&s=#{options[:size]}"
+        attributes[:width] = options[:size]
+        attributes[:height] = options[:size]
+      end
+
+      image_tag(uri.to_s, attributes)
+    end
+
+    def github_commit_range_url(stack, since_commit, until_commit)
+      github_repo_url(stack.repo_owner, stack.repo_name, 'compare', "#{since_commit.sha}...#{until_commit.sha}")
+    end
+
+    def github_user_url(user, *args)
+      [Shipit.github_url, user, *args].join('/')
+    end
+
+    def render_github_user(user)
+      link_to(github_user_url(user.login), class: 'user main-user') do
+        github_avatar(user, size: 20) + user.name
+      end
+    end
+
+    def github_repo_url(owner, repo, *args)
+      github_user_url(owner, repo, *args)
+    end
+
+    def github_commit_url(commit)
+      github_repo_url(commit.stack.repo_owner, commit.stack.repo_name, 'commit', commit.sha)
+    end
+
+    def github_diff_url(owner, repo, from_sha, to_sha)
+      github_repo_url(owner, repo, 'compare', "#{from_sha}...#{to_sha}")
+    end
+
+    def link_to_github_deploy(deploy)
+      url = github_commit_range_url(deploy.stack, *deploy.commit_range)
+      text = deploy.commit_range.map(&:short_sha).join('...')
+      link_to(text, url, class: 'number')
+    end
+  end
+end