rrrspec-web 0.2.0 → 0.2.1

data/assets/stylesheets/application.sass

@@ -0,0 +1,188 @@
+@import "bootstrap"
+
+body
+  padding-top: 20px
+
+dl
+  @extend .dl-horizontal
+
+.log
+  @extend .pre-scrollable
+  word-wrap: normal
+  white-space: pre
+  overflow-x: scroll
+
+.tasksets
+  ul
+    list-style-type: none
+    padding-left: 0
+
+    li
+      display: inline-block
+
+  .taskset-status
+    width: 7em
+    text-transform: uppercase
+  .username
+    width: 8em
+    padding-right: 2em
+
+.taskset
+  @extend .container
+
+  .head, .tasks, .worker-logs, .slaves
+    @extend .panel
+    @extend .panel-default
+
+    > .panel-heading
+      cursor: pointer
+      font-size: large
+      &:hover
+        color: darken(#428bca, 15%)
+        border-color: #428bca
+
+  .tasks-list, .worker-logs-list, .slaves-list
+    > *
+      padding: 0
+
+    .list-group-item > *
+      padding: 10px 15px
+
+  .head
+    .panel-heading
+      .name
+        font-size: x-large
+        overflow: hidden
+        text-overflow: ellipsis
+        white-space: nowrap
+        float: left
+        width: 80%
+
+      .status
+        font-size: large
+        width: 20%
+        text-transform: uppercase
+        float: left
+
+      .running
+        @extend .label-primary
+      .succeeded
+        @extend .label-success
+      .cancelled
+        @extend .label-warning
+      .failed
+        @extend .label-danger
+
+  .progressbars
+    .spec-progress
+      @extend .progress
+      .spec-progress-bar
+        @extend .progress-bar
+      .passed-spec-bar
+        @extend .progress-bar
+        @extend .progress-bar-success
+      .pending-spec-bar
+        @extend .progress-bar
+        @extend .progress-bar-warning
+      .failed-spec-bar
+        @extend .progress-bar
+        @extend .progress-bar-danger
+    .example-progress
+      @extend .progress
+      .passed-example-bar
+        @extend .progress-bar
+        @extend .progress-bar-success
+      .pending-example-bar
+        @extend .progress-bar
+        @extend .progress-bar-warning
+      .failed-example-bar
+        @extend .progress-bar
+        @extend .progress-bar-danger
+
+  .tasks
+    .tasks-heading
+      @extend .panel-heading
+
+    .tasks-list
+      @extend .list-group
+
+    .tasks-list-header, .tasks-list-item-header
+      list-style-type: none
+
+      li
+        display: inline-block
+
+      .taskstatus, .trial-count, .estimate-sec
+        width: 6em
+        text-align: center
+
+      .trial-count, .estimate-sec
+        @extend .pull-right
+
+      .file
+        text-align: left
+        text-overflow: ellipsis
+
+    .tasks-list-item-header
+      cursor: pointer
+
+    .running .tasks-list-item-header
+      background-color: #f5f5f5
+      &:hover
+        background-color: darken(#f5f5f5, 20%)
+    .passed .tasks-list-item-header
+      background-color: #dff0d8
+      &:hover
+        background-color: darken(#dff0d8, 20%)
+    .pending .tasks-list-item-header
+      background-color: #fcf8e3
+      &:hover
+        background-color: darken(#fcf8e3, 20%)
+    .failed .tasks-list-item-header
+      background-color: #f2dede
+      &:hover
+        background-color: darken(#f2dede, 20%)
+
+    .tasks-list-item-header
+      .taskstatus
+        text-transform: uppercase
+
+  .trials-list-heading
+    @extend .panel-heading
+
+  .worker-logs
+    .worker-logs-heading
+      @extend .panel-heading
+
+    .worker-logs-list
+      @extend .list-group
+
+    .worker-logs-list-item-header
+      cursor: pointer
+      &:hover
+        color: darken(#428bca, 15%)
+        text-decoration: underline
+
+  .slaves
+    .slaves-heading
+      @extend .panel-heading
+
+    .slaves-list
+      @extend .list-group
+
+    .slaves-list-item-header
+      cursor: pointer
+      &:hover
+        color: darken(#428bca, 15%)
+        text-decoration: underline
+
+    .exit-status
+      @extend .pull-right
+      text-transform: uppercase
+
+    .normal_exit .slaves-list-item-header
+      background-color: #dff0d8
+    .timeout_exit .slaves-list-item-header
+      background-color: #fcf8e3
+    .failure_exit .slaves-list-item-header
+      background-color: #f2dede

data/lib/rrrspec/web/api.rb

@@ -1,5 +1,6 @@
 require 'grape'
 require 'api-pagination'
+require 'oj'
 
 module RRRSpec
   module Web
@@ -51,5 +52,65 @@ module RRRSpec
         end
       end
     end
+
+    module OjFormatter
+      def self.call(object, env)
+        Oj.dump(object, mode: :compat, time_format: :ruby)
+      end
+    end
+
+    class APIv2 < Grape::API
+      version 'v2', using: :path
+      format :json
+      formatter :json, OjFormatter
+
+      rescue_from(ActiveRecord::RecordNotFound) do
+        [404, {}, ['']]
+      end
+
+      # For Index
+
+      get '/tasksets/actives' do
+        ActiveTaskset.list
+      end
+
+      get '/tasksets/recents' do
+        paginate(RRRSpec::Server::Persistence::Taskset.recent).map(&:as_json_for_index)
+      end
+
+      # For Result Page
+
+      # Notice that this method takes taskset key.
+      params { requires :taskset_key, type: String }
+      get '/tasksets/:taskset_key' do
+        RRRSpec::Server::Persistence::Taskset.includes(tasks: :trials).where(key: params[:taskset_key]).first!.as_json_for_result_page
+      end
+
+      params { requires :taskset_id, type: Integer }
+      get '/tasksets/:taskset_id/log' do
+        { 'log' => RRRSpec::Server::Persistence::Taskset.find(params[:taskset_id]).log.to_s }
+      end
+
+      params { requires :task_id, type: Integer }
+      get '/tasks/:task_id/trials' do
+        RRRSpec::Server::Persistence::Task.find(params[:task_id]).trials.map(&:as_json_for_result_page)
+      end
+
+      params { requires :trial_id, type: Integer }
+      get '/trials/:trial_id/outputs' do
+        trial = RRRSpec::Server::Persistence::Trial.find(params[:trial_id])
+        { 'stdout' => trial.stdout.to_s, 'stderr' => trial.stderr.to_s }
+      end
+
+      params { requires :taskset_id, type: Integer }
+      get '/tasksets/:taskset_id/worker_logs' do
+        RRRSpec::Server::Persistence::Taskset.find(params[:taskset_id]).worker_logs.map(&:as_json_for_result_page)
+      end
+
+      params { requires :taskset_id, type: Integer }
+      get '/tasksets/:taskset_id/slaves' do
+        RRRSpec::Server::Persistence::Taskset.includes(slaves: :trials).find(params[:taskset_id]).slaves.map(&:as_json_for_result_page)
+      end
+    end
   end
 end

data/lib/rrrspec/web/app.rb

@@ -1,5 +1,5 @@
 require 'sinatra/base'
-require 'sinatra/assetpack'
+require 'sinatra/asset_pipeline'
 require 'haml'
 require 'sass'
 require 'coffee-script'
@@ -7,40 +7,19 @@ require 'coffee-script'
 module RRRSpec
   module Web
     class App < Sinatra::Base
+      set :assets_precompile, %w(application.css tasksets.js index.js)
+      set :assets_prefix, [
+        "#{Gem::Specification.find_by_name('bootstrap-sass').gem_dir}/vendor/assets",
+        File.expand_path('../../../../assets', __FILE__),
+      ]
+
+      register Sinatra::AssetPipeline
+
       configure do
         set :root, File.expand_path(File.join(__FILE__, '..', '..', '..', '..'))
         set :haml, :format => :html5
       end
 
-      register Sinatra::AssetPack
-
-      assets do
-        JSLIBS = [
-          '/js/vendor/jquery-1.10.2.min.js',
-          '/js/vendor/underscore-min.js',
-          '/js/vendor/backbone-min.js',
-          '/js/vendor/mustache.js',
-          '/js/vendor/bootstrap.min.js',
-          '/js/vendor/moment.min.js',
-          '/js/models.js',
-        ]
-
-        CSSLIBS = [
-          '/css/vendor/bootstrap.min.css',
-          '/css/vendor/bootstrap-theme.min.css',
-        ]
-
-        js :tasksets, JSLIBS + ["/js/tasksets.js"]
-        js :index, JSLIBS + ["/js/index.js"]
-        css :application, CSSLIBS + ["/css/application.css"]
-
-        js_compression :jsmin
-        css_compression :simple
-
-        prebuild true
-        cache_dynamic_assets true
-      end
-
       get('/') { haml :index }
       get('/tasksets/*') { haml :taskset }
     end

data/lib/rrrspec/web/configuration.rb

@@ -1,6 +1,7 @@
 module RRRSpec
   module Web
     class WebConfiguration < RRRSpec::Configuration
+      attr_accessor :execute_log_text_path
       attr_accessor :persistence_db
 
       def initialize

data/lib/rrrspec/web/persistent_models.rb

@@ -4,8 +4,13 @@ module RRRSpec
   module Server
     module Persistence
       class Taskset
-        scope :recent, order('finished_at DESC')
-        scope :has_failed_slaves, includes(:slaves).where(slaves: {status: 'failure_exit'})
+        def self.recent
+          order('finished_at DESC')
+        end
+
+        def self.has_failed_slaves
+          includes(:slaves).where(slaves: {status: 'failure_exit'})
+        end
 
         def as_json_with_no_relation
           as_json(except: :id)

data/lib/rrrspec/web/version.rb

@@ -1,5 +1,5 @@
 module RRRSpec
   module Web
-    VERSION = "0.2.0"
+    VERSION = "0.2.1"
   end
 end

data/rrrspec-web.gemspec

@@ -24,24 +24,26 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_development_dependency "bundler", "~> 1.4"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec"
-  spec.add_development_dependency "rack-test"
   spec.add_development_dependency "database_cleaner", "~> 1.2.0"
-  spec.add_development_dependency "sqlite3"
-  spec.add_development_dependency "mysql2"
   spec.add_development_dependency "guard-livereload"
+  spec.add_development_dependency "mysql2"
   spec.add_development_dependency "rack-livereload"
-  spec.add_dependency "activerecord", "~> 3.0"
+  spec.add_development_dependency "rack-test"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "sqlite3"
+  spec.add_dependency "activerecord", "~> 4.0.2"
   spec.add_dependency "activesupport"
   spec.add_dependency "api-pagination"
+  spec.add_dependency "bootstrap-sass"
   spec.add_dependency "coffee-script", "~> 2.2.0"
   spec.add_dependency "grape"
   spec.add_dependency "haml", "~> 4.0.3"
   spec.add_dependency "kaminari", "~> 0.15.0"
+  spec.add_dependency "oj"
   spec.add_dependency "rrrspec-client"
   spec.add_dependency "rrrspec-server"
   spec.add_dependency "sass"
   spec.add_dependency "sinatra", "~> 1.4.3"
-  spec.add_dependency "sinatra-assetpack"
+  spec.add_dependency "sinatra-asset-pipeline"
 end

data/spec/rrrspec/web/api_spec.rb

@@ -1,16 +1,15 @@
 require 'spec_helper'
 
 module RRRSpec
-  describe Web::API do
-    include Rack::Test::Methods
-
-    def app
-      Web::API
-    end
-
+  describe "Web" do
     before do
-      RRRSpec.configuration = Configuration.new
+      RRRSpec.configuration = Web::WebConfiguration.new
       RRRSpec.configuration.redis = @redis
+      RRRSpec.configuration.execute_log_text_path = Dir.mktmpdir
+    end
+
+    after do
+      FileUtils.remove_entry_secure(RRRSpec.configuration.execute_log_text_path)
     end
 
     let(:taskset) do
@@ -23,96 +22,328 @@ module RRRSpec
       Task.create(taskset, 10, 'spec/test_spec.rb')
     end
 
-    let(:worker) do
+    let!(:worker) do
       Worker.create('default')
     end
 
-    let(:worker_log) do
+    let!(:worker_log) do
       WorkerLog.create(worker, taskset)
     end
 
-    let(:slave) do
+    let!(:slave) do
       Slave.create
     end
 
+    let(:trial) do
+      Trial.create(task, slave)
+    end
+
+    def taskset_id
+      RRRSpec::Server::Persistence::Taskset.by_redis_model(taskset).first!.id
+    end
+
     before do
-      worker # Create worker
       taskset.add_task(task)
       taskset.enqueue_task(task)
+
       ActiveTaskset.add(taskset)
-      worker_log # Create worker_log
+
       worker_log.set_rsync_finished_time
       worker_log.append_log('worker_log log body')
       worker_log.set_setup_finished_time
-      slave # Create slave
+
       taskset.add_slave(slave)
       slave.append_log('slave log body')
-      trial = Trial.create(task, slave)
+
       trial.start
       trial.finish('pending', 'stdout body', 'stderr body', 10, 2, 0)
+
       task.update_status('pending')
+      taskset.append_log('taskset log body')
+
       taskset.incr_succeeded_count
       taskset.finish_task(task)
       taskset.update_status('succeeded')
       taskset.set_finished_time
+
       ActiveTaskset.remove(taskset)
+
       slave.update_status('normal_exit')
+
       worker_log.set_finished_time
     end
 
-    describe "GET /v1/tasksets/actives" do
-      before { ActiveTaskset.add(taskset) }
+    describe Web::API do
+      include Rack::Test::Methods
 
-      it 'returns the active tasksets' do
-        get "/v1/tasksets/actives"
-        expect(last_response.status).to eq(200)
-        expect(JSON.parse(last_response.body)).to eq(JSON.parse(ActiveTaskset.list.to_json))
+      def app
+        Web::API
       end
-    end
 
-    describe "GET /v1/tasksets/recents" do
-      context 'there are 11 tasksets' do
-        before do
-          11.times { Server::Persistence::Taskset.create() }
+      describe "GET /v1/tasksets/actives" do
+        before { ActiveTaskset.add(taskset) }
+
+        it 'returns the active tasksets' do
+          get "/v1/tasksets/actives"
+          expect(last_response.status).to eq(200)
+          expect(JSON.parse(last_response.body)).to eq(JSON.parse(ActiveTaskset.list.to_json))
+        end
+      end
+
+      describe "GET /v1/tasksets/recents" do
+        context 'there are 11 tasksets' do
+          before do
+            11.times { Server::Persistence::Taskset.create() }
+          end
+
+          it 'returns the recent 10 tasksets' do
+            get "/v1/tasksets/recents"
+            expect(last_response.status).to eq(200)
+            expect(JSON.parse(last_response.body).size).to eq(10)
+          end
+        end
+      end
+
+      describe "GET /v1/tasksets/:key" do
+        context 'with the taskset persisted' do
+          before do
+            Server::Persister.persist(taskset)
+          end
+
+          it 'returns the taskset' do
+            get "/v1/tasksets/#{taskset.key}"
+            expect(last_response.status).to eq(200)
+            expect(JSON.parse(last_response.body)).to eq(
+              JSON.parse(JSON.generate(Server::Persistence::Taskset.first.as_full_json)).update("is_full" => true)
+            )
+          end
         end
 
-        it 'returns the recent 10 tasksets' do
-          get "/v1/tasksets/recents"
+        context 'with the taskset not persisted' do
+          it 'returns 404' do
+            get "/v1/tasksets/#{taskset.key}"
+            expect(last_response.status).to eq(404)
+          end
+        end
+      end
+
+      describe "GET /v1/batch/tasks/:key" do
+        it 'returns all tasks in the taskset' do
+          get "/v1/batch/tasks/#{taskset.key}"
           expect(last_response.status).to eq(200)
-          expect(JSON.parse(last_response.body).size).to eq(10)
+          expect(JSON.parse(last_response.body)).to eq([JSON.parse(task.to_json)])
         end
       end
     end
 
-    describe "GET /v1/tasksets/:key" do
-      context 'with the taskset persisted' do
+    describe Web::APIv2 do
+      include Rack::Test::Methods
+
+      def app
+        Web::APIv2
+      end
+
+      describe "GET /v2/tasksets/actives" do
+        before { ActiveTaskset.add(taskset) }
+
+        it 'returns the active tasksets' do
+          get "/v2/tasksets/actives"
+          expect(last_response.status).to eq(200)
+          expect(JSON.parse(last_response.body)).to eq([
+            { 'key' => taskset.key },
+          ])
+        end
+      end
+
+      describe "GET /v2/tasksets/recents" do
+        context 'there are 11 tasksets' do
+          before do
+            11.times { Server::Persistence::Taskset.create() }
+          end
+
+          it 'returns the recent 10 tasksets' do
+            get "/v2/tasksets/recents"
+            expect(last_response.status).to eq(200)
+            expect(JSON.parse(last_response.body).size).to eq(10)
+          end
+        end
+      end
+
+      shared_context 'the taskset is persisted' do
         before do
           Server::Persister.persist(taskset)
         end
+      end
 
-        it 'returns the taskset' do
-          get "/v1/tasksets/#{taskset.key}"
-          expect(last_response.status).to eq(200)
-          expect(JSON.parse(last_response.body)).to eq(
-            JSON.parse(JSON.generate(Server::Persistence::Taskset.first.as_full_json)).update("is_full" => true)
-          )
+      describe 'GET /v2/tasksets/:taskset_key' do
+        context "when the taskset is persisted" do
+          include_context 'the taskset is persisted'
+
+          it 'returns a taskset in JSON' do
+            get "/v2/tasksets/#{taskset.key}"
+            expect(last_response.status).to eq(200)
+            expect(JSON.parse(last_response.body)).to eq({
+              "created_at" => taskset.created_at.iso8601,
+              "finished_at" => taskset.finished_at.iso8601,
+              "id" => 1,
+              "key" => taskset.key,
+              "max_trials" => 3,
+              "max_workers" => 3,
+              "rsync_name" => "testuser",
+              "setup_command" => "echo 1",
+              "slave_command" => "echo 2",
+              "status" => "succeeded",
+              "tasks" => [
+                {
+                  "id" => 1,
+                  "key" => task.key,
+                  "status" => "pending",
+                  "spec_path" => "spec/test_spec.rb",
+                  "estimate_sec" => 10,
+                  "trials" => [
+                    {
+                      "id" => 1,
+                      "key" => trial.key,
+                      "task_id" => 1,
+                      "slave_id" => 1,
+                      "started_at" => trial.started_at.iso8601,
+                      "finished_at" => trial.finished_at.iso8601,
+                      "status" => "pending",
+                      "passed" => 10,
+                      "pending" => 2,
+                      "failed" => 0
+                    },
+                  ],
+                },
+              ],
+              "taskset_class" => "default",
+              "worker_type" => "default",
+            })
+          end
+        end
+
+        context "when the taskset is not persisted" do
+          it "returns 404" do
+            get "/v2/tasksets/#{taskset.key}"
+            expect(last_response.status).to eq(404)
+          end
         end
       end
 
-      context 'with the taskset not persisted' do
-        it 'returns 404' do
-          get "/v1/tasksets/#{taskset.key}"
-          expect(last_response.status).to eq(404)
+      describe 'GET /v2/tasksets/:taskset_id/log' do
+        context "when the taskset is persisted" do
+          include_context 'the taskset is persisted'
+
+          it 'returns a string in JSON' do
+            get "/v2/tasksets/#{taskset_id}/log"
+            expect(last_response.status).to eq(200)
+            expect(JSON.parse(last_response.body)).to eq({
+              'log' => 'taskset log body',
+            })
+          end
+        end
+
+        context "when the taskset is not persisted" do
+          it "returns 404" do
+            get "/v2/tasksets/0/log"
+            expect(last_response.status).to eq(404)
+          end
         end
       end
-    end
 
-    describe "GET /v1/batch/tasks/:key" do
-      it 'returns all tasks in the taskset' do
-        get "/v1/batch/tasks/#{taskset.key}"
-        expect(last_response.status).to eq(200)
-        expect(JSON.parse(last_response.body)).to eq([JSON.parse(task.to_json)])
+      describe 'GET /v2/tasks/:task_id/trials' do
+        context "when the taskset is persisted" do
+          include_context 'the taskset is persisted'
+
+          it 'returns trials in JSON' do
+            get "/v2/tasks/#{taskset_id}/trials"
+            expect(last_response.status).to eq(200)
+            expect(JSON.parse(last_response.body)).to eq([
+              {
+                "id" => 1,
+                "key" => trial.key,
+                "task_id" => 1,
+                "slave_id" => 1,
+                "started_at" => trial.started_at.iso8601,
+                "finished_at" => trial.finished_at.iso8601,
+                "status" => "pending",
+                "passed" => 10,
+                "pending" => 2,
+                "failed" => 0,
+              },
+            ])
+          end
+        end
+
+        context "when the taskset is not persisted" do
+          it "returns 404" do
+            get "/v2/tasksets/#{taskset.key}/trials"
+            expect(last_response.status).to eq(404)
+          end
+        end
       end
+
+      describe 'GET /v2/tasksets/:taskset_id/worker_logs' do
+        context "when the taskset is persisted" do
+          include_context 'the taskset is persisted'
+
+          it 'returns worker logs in JSON' do
+            get "/v2/tasksets/#{taskset_id}/worker_logs"
+            expect(last_response.status).to eq(200)
+            expect(JSON.parse(last_response.body)).to eq([
+              {
+                "id" => 1,
+                "worker_name" => "rrrspec:worker:testhostname",
+                "started_at" => worker_log.started_at.iso8601,
+                "rsync_finished_at" => worker_log.rsync_finished_at.iso8601,
+                "setup_finished_at" => worker_log.setup_finished_at.iso8601,
+                "rspec_finished_at" => worker_log.finished_at.iso8601,
+                "log" => "worker_log log body",
+              },
+            ])
+          end
+        end
+
+        context "when the taskset is not persisted" do
+          it "returns 404" do
+            get "/v2/tasksets/0/worker_logs"
+            expect(last_response.status).to eq(404)
+          end
+        end
+      end
+
+      describe 'GET /v2/tasksets/:taskset_id/slaves' do
+        context "when the taskset is persisted" do
+          include_context 'the taskset is persisted'
+
+          it 'returns slaves in JSON' do
+            get "/v2/tasksets/#{taskset_id}/slaves"
+            expect(last_response.status).to eq(200)
+            expect(JSON.parse(last_response.body)).to eq([
+              {
+                "id" => 1,
+                "name" => slave.key,
+                "status" => "normal_exit",
+                "trials" => [
+                  {
+                    "id" => 1,
+                    "key" => trial.key,
+                  },
+                ],
+                "log" => "slave log body",
+              },
+            ])
+          end
+        end
+
+        context "when the taskset is not persisted" do
+          it "returns 404" do
+            get "/v2/tasksets/0/slaves"
+            expect(last_response.status).to eq(404)
+          end
+        end
+      end
+
     end
   end
 end