Merge pull request #257 from bmarkons/manual-run-releases

Run releases through admin UI

Author: Marko Bogdanović

app/assets/javascripts/admin/manual_run.js

@@ -1,7 +1,12 @@
 $(document).on('turbolinks:load', function() {
-  $('#manual_run_form').submit(function(event) {
+  $('#commits_run_form').submit(function(event) {
     $('#notice').remove();
-    $('#wait_alert').removeClass('hidden');
+    $('#wait_commits_alert').removeClass('hidden');
+  });
+  
+  $('#releases_run_form').submit(function(event) {
+    $('#notice').remove();
+    $('#wait_releases_alert').removeClass('hidden');
   });
 });
 

app/controllers/admin/dashboard_controller.rb

@@ -0,0 +1,4 @@
+class Admin::DashboardController < AdminController
+  def dashboard
+  end
+end

app/controllers/admin/groups_controller.rb

@@ -1,12 +1,4 @@
-class Admin::GroupsController < ApplicationController
-  http_basic_authenticate_with(
-    name: 'admin',
-    password: Rails.application.secrets.admin_password
-  ) unless Rails.env.test?
-
-  layout 'admin'
-
-  before_action :set_repos, :set_admin
+class Admin::GroupsController < AdminController
   before_action :set_group, only: [:show, :edit, :update, :destroy]
 
   def index

app/controllers/admin/repos_controller.rb

@@ -0,0 +1,45 @@
+class Admin::ReposController < AdminController
+  before_action :set_repo
+
+  def show
+  end
+
+  def run_commits
+    ManualRunner.new(@repo).run_last(
+      commits_count,
+      pattern: pattern
+    )
+
+    redirect_to admin_repo_path(@repo.name), notice: "#{@repo.name.capitalize} suite is running for last #{params[:count].to_i} commits."
+  end
+
+  def run_releases
+    unless versions.empty?
+      ManualRunner.new(@repo).run_releases(
+        versions,
+        pattern: pattern
+      )
+      redirect_to admin_repo_path(@repo.name), notice: "#{@repo.name.capitalize} suite is running for selected versions."
+    else
+      redirect_to admin_repo_path(@repo.name), notice: 'You need to select release versions you want to run.'
+    end
+  end
+
+  private
+
+  def set_repo
+    @repo = Repo.find_by(name: params[:repo_name])
+  end
+
+  def versions
+    params[:versions].split(',')
+  end
+
+  def pattern
+    params[:pattern] == 'all' ? '' : params[:pattern]
+  end
+
+  def commits_count
+    params[:count].to_i
+  end
+end

app/controllers/admin_controller.rb

@@ -7,34 +7,14 @@ class AdminController < ApplicationController
   layout 'admin'
 
   before_action :set_repos, :set_admin
-  before_action :set_repo, only: [:repo, :run]
+
+  private
 
   def set_admin
     session['admin'] = true unless session['admin'] || Rails.env.test?
   end
 
-  def home
-  end
-
-  def repo
-  end
-
-  def run
-    ManualRunner.new(@repo).run_last(
-      params[:count].to_i,
-      pattern: params[:pattern] == 'all' ? '' : params[:pattern]
-    )
-
-    redirect_to admin_repo_path(@repo.name), notice: "#{@repo.name.capitalize} suite is running for last #{params[:count].to_i} commits."
-  end
-
-  private
-
   def set_repos
     @repos = Repo.all
   end
-
-  def set_repo
-    @repo = Repo.find_by(name: params[:repo_name])
-  end
 end

app/jobs/remote_server_job.rb

@@ -5,18 +5,18 @@ class RemoteServerJob < ActiveJob::Base
 
   SCRIPTS_PATH = './ruby-bench-docker/scripts'
 
-  RUBY_TRUNK = "#{SCRIPTS_PATH}/ruby/trunk.sh"
+  RUBY_COMMIT = "#{SCRIPTS_PATH}/ruby/trunk.sh"
   RUBY_RELEASE = "#{SCRIPTS_PATH}/ruby/releases.sh"
 
-  RAILS_MASTER = "#{SCRIPTS_PATH}/rails/master.sh"
+  RAILS_COMMIT = "#{SCRIPTS_PATH}/rails/master.sh"
   RAILS_RELEASE = "#{SCRIPTS_PATH}/rails/releases.sh"
 
-  SEQUEL_MASTER = "#{SCRIPTS_PATH}/sequel/master.sh"
+  SEQUEL_COMMIT = "#{SCRIPTS_PATH}/sequel/master.sh"
   SEQUEL_RELEASE = "#{SCRIPTS_PATH}/sequel/releases.sh"
 
   BUNDLER_RELEASE = "#{SCRIPTS_PATH}/bundler/releases.sh"
 
-  PG_MASTER = "#{SCRIPTS_PATH}/pg/master.sh"
+  PG_COMMIT = "#{SCRIPTS_PATH}/pg/master.sh"
 
   # Use keyword arguments once Rails 4.2.1 has been released.
   def perform(initiator_key, benchmark_group, options = {})
@@ -32,7 +32,7 @@ def perform(initiator_key, benchmark_group, options = {})
 
   private
 
-  def ruby_trunk(ssh, commit_hash, options)
+  def ruby_commit(ssh, commit_hash, options)
     ruby = true
     memory = true
     optcarrot = true
@@ -41,11 +41,11 @@ def ruby_trunk(ssh, commit_hash, options)
 
     ssh_exec!(
       ssh,
-      "#{RUBY_TRUNK} #{ruby} #{memory} #{optcarrot} #{liquid} #{commit_hash} #{secrets.api_name} #{secrets.api_password} #{patterns}"
+      "#{RUBY_COMMIT} #{ruby} #{memory} #{optcarrot} #{liquid} #{commit_hash} #{secrets.api_name} #{secrets.api_password} #{patterns}"
     )
   end
 
-  def ruby_releases(ssh, version, options)
+  def ruby_release(ssh, version, options)
     ruby = true
     memory = true
     optcarrot = true
@@ -58,7 +58,7 @@ def ruby_releases(ssh, version, options)
     )
   end
 
-  def ruby_releases_discourse(ssh, ruby_version, options)
+  def ruby_release_discourse(ssh, ruby_version, options)
     execute_ssh_commands(ssh,
       [
         'docker pull rubybench/ruby_releases_discourse',
@@ -77,7 +77,7 @@ def ruby_releases_discourse(ssh, ruby_version, options)
     )
   end
 
-  def ruby_trunk_discourse(ssh, commit_hash, options)
+  def ruby_commit_discourse(ssh, commit_hash, options)
     execute_ssh_commands(ssh,
       [
         'docker pull rubybench/ruby_trunk_discourse',
@@ -94,41 +94,41 @@ def ruby_trunk_discourse(ssh, commit_hash, options)
     )
   end
 
-  def rails_releases(ssh, version, options)
+  def rails_release(ssh, version, options)
     prepared_statements = if version >= '4.2.5' then 1 else 0 end
     patterns = options[:include_patterns]
 
     ssh_exec!(ssh, "#{RAILS_RELEASE} #{version} #{secrets.api_name} #{secrets.api_password} #{prepared_statements} #{patterns}")
   end
 
-  def rails_trunk(ssh, commit_hash, options)
+  def rails_commit(ssh, commit_hash, options)
     patterns = options[:include_patterns]
 
-    ssh_exec!(ssh, "#{RAILS_MASTER} #{commit_hash} #{secrets.api_name} #{secrets.api_password} #{patterns}")
+    ssh_exec!(ssh, "#{RAILS_COMMIT} #{commit_hash} #{secrets.api_name} #{secrets.api_password} #{patterns}")
   end
 
-  def sequel_releases(ssh, version, options)
+  def sequel_release(ssh, version, options)
     patterns = options[:include_patterns]
 
     ssh_exec!(ssh, "#{SEQUEL_RELEASE} #{version} #{secrets.api_name} #{secrets.api_password} #{patterns}")
   end
 
-  def sequel_trunk(ssh, commit_hash, options)
+  def sequel_commit(ssh, commit_hash, options)
     patterns = options[:include_patterns]
 
-    ssh_exec!(ssh, "#{SEQUEL_MASTER} #{commit_hash} #{secrets.api_name} #{secrets.api_password} #{patterns}")
+    ssh_exec!(ssh, "#{SEQUEL_COMMIT} #{commit_hash} #{secrets.api_name} #{secrets.api_password} #{patterns}")
   end
 
-  def bundler_releases(ssh, version, options)
+  def bundler_release(ssh, version, options)
     patterns = options[:include_patterns]
 
     ssh_exec!(ssh, "#{BUNDLER_RELEASE} #{version} #{secrets.api_name} #{secrets.api_password} #{patterns}")
   end
 
-  def pg_master(ssh, commit_hash, options)
+  def pg_commit(ssh, commit_hash, options)
     patterns = options[:include_patterns]
 
-    ssh_exec!(ssh, "#{PG_MASTER} #{commit_hash} #{secrets.api_name} #{secrets.api_password} #{patterns}")
+    ssh_exec!(ssh, "#{PG_COMMIT} #{commit_hash} #{secrets.api_name} #{secrets.api_password} #{patterns}")
   end
 
   def execute_ssh_commands(ssh, commands)

app/services/benchmark_pool.rb

@@ -1,15 +1,14 @@
 module BenchmarkPool
-  def self.enqueue(repo_name, commit_sha, options = {})
+  def self.enqueue(initiator_type, initiator, repo_name, options = {})
     case repo_name
     when 'ruby'
-      RemoteServerJob.perform_later(commit_sha, 'ruby_trunk', options)
-      # RemoteServerJob.perform_later(commit_sha, 'ruby_trunk_discourse')
+      RemoteServerJob.perform_later(initiator, "ruby_#{initiator_type}", options)
     when 'rails'
-      RemoteServerJob.perform_later(commit_sha, 'rails_trunk', options)
+      RemoteServerJob.perform_later(initiator, "rails_#{initiator_type}", options)
     when 'sequel'
-      RemoteServerJob.perform_later(commit_sha, 'sequel_trunk', options)
+      RemoteServerJob.perform_later(initiator, "sequel_#{initiator_type}", options)
     when 'ruby-pg'
-      RemoteServerJob.perform_later(commit_sha, 'pg_master', options)
+      RemoteServerJob.perform_later(initiator, "pg_#{initiator_type}", options)
     else
       raise ArgumentError, "unknown repo: #{repo_name}"
     end

app/services/commits_runner.rb

@@ -1,12 +1,45 @@
-class CommitsRunner
-  def self.run(commits, pattern = '')
-    commits.select { |commit| valid?(commit) }
-           .each { |commit| create_and_run(commit, pattern) }
-           .count
+module CommitsRunner
+  def self.run(trigger_source, commits, repo, pattern = '')
+    formatted_commits =
+      if trigger_source == :webhook
+        format_webhook(commits, repo)
+      elsif trigger_source == :api
+        format_api(commits, repo)
+      end
+
+    formatted_commits.select { |commit| valid?(commit) }
+                     .each { |commit| create_and_run(commit, pattern) }
+                     .count
   end
 
   private
 
+  def self.format_api(commits, repo)
+    commits.map do |commit|
+      {
+        sha: commit['sha'],
+        message: commit['commit']['message'],
+        repo: repo,
+        url: commit['html_url'],
+        created_at: commit['commit']['author']['date'],
+        author_name: commit['commit']['author']['name']
+      }
+    end
+  end
+
+  def self.format_webhook(commits, repo)
+    commits.map do |commit|
+      {
+        sha: commit['id'],
+        message: commit['message'],
+        repo: repo,
+        url: commit['url'],
+        created_at: commit['timestamp'],
+        author_name: commit['author']['name']
+      }
+    end
+  end
+
   def self.valid?(commit)
     !Commit.merge_or_skip_ci?(commit[:message]) && Commit.valid_author?(commit[:author_name])
   end
@@ -20,8 +53,9 @@ def self.create_and_run(commit, pattern)
     end
 
     BenchmarkPool.enqueue(
-      commit[:repo].name,
+      :commit,
       commit[:sha],
+      commit[:repo].name,
       include_patterns: pattern
     )
   end

app/services/github_event_handler.rb

@@ -25,19 +25,14 @@ def branch_from_payload
     @payload['ref'].split('/')[2]
   end
 
-  # Grabs the commits hash and starts job to run benchmarks on remote server.
   def process_push
-    repo = first_or_create_repo(@payload['repository'])
+    repo = find_or_create_repo(@payload['repository'])
     commits = @payload['commits'] || [@payload['head_commit']]
 
-    commits.each do |commit|
-      if create_commit(commit, repo.id)
-        BenchmarkPool.enqueue(repo.name, commit['id'])
-      end
-    end
+    CommitsRunner.run(:webhook, commits, repo)
   end
 
-  def first_or_create_repo(repository)
+  def find_or_create_repo(repository)
     organization_name, repo_name = parse_full_name(repository['full_name'])
     repository_url = repository['html_url']
 
@@ -65,19 +60,4 @@ def parse_full_name(full_name)
     full_name =~ /\A(\w+)\/(\w+)/
     [$1, $2]
   end
-
-  def create_commit(commit, repo_id)
-    if valid_commit?(commit)
-      Commit.find_or_create_by(sha1: commit['id']) do |c|
-        c.url = commit['url']
-        c.message = commit['message']
-        c.repo_id = repo_id
-        c.created_at = commit['timestamp']
-      end
-    end
-  end
-
-  def valid_commit?(commit)
-    !Commit.merge_or_skip_ci?(commit['message']) && Commit.valid_author?(commit['author']['name'])
-  end
 end

app/services/manual_runner.rb

@@ -7,6 +7,10 @@ def initialize(repo)
     @octokit = Octokit::Client.new(access_token: Rails.application.secrets.github_api_token)
   end
 
+  def run_releases(versions, pattern: '')
+    ReleasesRunner.run(versions, @repo, pattern)
+  end
+
   def run_last(commits_count, pattern: '')
     if commits_count < 100
       run_commits(per_page: commits_count, pattern: pattern)
@@ -25,21 +29,7 @@ def run_paginated(commits_count, page: 1, pattern: '')
   end
 
   def run_commits(page: 1, per_page: 100, pattern: '')
-    fetched_commits = @octokit.commits("#{@repo.organization.name}/#{@repo.name}", per_page: per_page, page: page)
-    formatted_commits = format_commits(fetched_commits)
-    CommitsRunner.run(formatted_commits, pattern)
-  end
-
-  def format_commits(commits)
-    commits.map do |commit|
-      {
-        sha: commit['sha'],
-        message: commit['commit']['message'],
-        repo: @repo,
-        url: commit['html_url'],
-        created_at: commit['commit']['author']['date'],
-        author_name: commit['commit']['author']['name']
-      }
-    end
+    commits = @octokit.commits("#{@repo.organization.name}/#{@repo.name}", per_page: per_page, page: page)
+    CommitsRunner.run(:api, commits, @repo, pattern)
   end
 end