inferno_core 0.3.11 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e278b200d33582c51a4dcfcee3c7ef321162ecbc0c1c12225601b8b03627747
-  data.tar.gz: 80a3cac6f4de4e9c191733bedc22e31182acc2ef135f1473a52ff971fd2ab0b2
+  metadata.gz: 987a2db725cb3b2517f392d2e566614f3e5fcd454f27164e6de64ec615b5661c
+  data.tar.gz: 1cce12a803e20d288e72f9f3b1dfd1def94f9cbe1fcb73f4c862f1063c3d5c8c
 SHA512:
-  metadata.gz: 5834a48e2c99300e08a1acacc040fa7a96fc85b74c6b5de4d64a3f0265e9c79dad017d7becc927c6bfd3be9ab690008c48223c29e129e8d28bc70edfe3e75e59
-  data.tar.gz: 7cfaa5b8d64596e7d245026cf35f93b2093c0517bcdcae7b14ed4778e369c3244ea1cf8ce8179153001ed82275293edea25379a9a0a5cf90aecd027ddb728b1f
+  metadata.gz: 646f385e975efc9eb957aa707934e7c3e04977c97bd73dae4a21a8dbfd60869c1662f1832bfac1a38cb534ed18ebc93d771937a8978a7fb5dba7e0b3db54b974
+  data.tar.gz: 106dc72ddaaba5f02be715aef376984adb7c97ae71c62668d45da094bcfe430ee1a7c5d940c99e92bfc645bc31c8bb2013406aaffb2a072fc1d0fc9771a3187f

data/lib/inferno/apps/cli/main.rb

@@ -1,5 +1,6 @@
 require_relative 'console'
 require_relative 'migration'
+require_relative 'services'
 require_relative 'suite'
 require_relative 'suites'
 
@@ -16,11 +17,23 @@ module Inferno
         Migration.new.run
       end
 
+      desc 'start', 'Start Inferno'
+      def start
+        if `gem list -i foreman`.chomp == 'false'
+          puts "You must install foreman with 'gem install foreman' prior to running inferno."
+        end
+
+        system 'foreman start --env=/dev/null'
+      end
+
       desc 'suites', 'List available test suites'
       def suites
         Suites.new.run
       end
 
+      desc 'services stop/start', 'Start or stop background services'
+      subcommand 'services', Services
+
       desc 'suite SUBCOMMAND ...ARGS', 'Perform suite-based operations'
       subcommand 'suite', Suite
     end

data/lib/inferno/apps/cli/services.rb

@@ -0,0 +1,56 @@
+module Inferno
+  module CLI
+    class Services < Thor
+      no_commands do
+        def base_command
+          'docker-compose -f docker-compose.background.yml'
+        end
+      end
+
+      desc 'start', 'Start background services'
+      option :foreground,
+             default: false,
+             type: :boolean,
+             desc: 'Run services in foreground'
+      def start
+        command = "#{base_command} up"
+        command += ' -d' unless options[:foreground]
+
+        system command
+      end
+
+      desc 'stop', 'Stop background services'
+      def stop
+        system "#{base_command} down"
+      end
+
+      desc 'build', 'Build background service images'
+      def build
+        system "#{base_command} build"
+      end
+
+      desc 'pull', 'Pull background service images'
+      def pull
+        system "#{base_command} pull"
+      end
+
+      desc 'logs', 'Display the logs for the background services'
+      option :follow,
+             default: false,
+             aliases: [:f],
+             type: :boolean,
+             desc: 'Follow log output'
+      option :tail,
+             banner: 'string',
+             default: 'all',
+             desc: 'Number of lines to show from the end of the logs for each container'
+      def logs
+        command = "#{base_command} logs"
+        command += ' -f' if options[:follow]
+        command += " --tail #{options[:tail]}" if options[:tail]
+
+        system command
+      end
+    end
+  end
+end

data/lib/inferno/apps/web/application.rb

@@ -1,4 +1,5 @@
 require 'hanami/middleware/body_parser'
+require_relative 'router'
 
 module Inferno
   module Web

data/lib/inferno/apps/web/controllers/controller.rb

@@ -1,20 +1,18 @@
 module Inferno
   module Web
     module Controllers
-      class Controller
-        # Ensure that each request gets a new instance of the controller.
-        def self.call(params)
-          new.call(params)
+      class Controller < Hanami::Action
+        def self.call(...)
+          new.call(...)
         end
 
         def self.inherited(subclass)
           super
 
-          # This does some sort of magic that requires it be included in the
-          # subclass rather than superclass.
-          subclass.include Hanami::Action
+          subclass.include Import[repo: "inferno.repositories.#{subclass.resource_name}"]
 
-          subclass.include Import[repo: "repositories.#{subclass.resource_name}"]
+          subclass.config.default_request_format = :json
+          subclass.config.default_response_format = :json
 
           subclass.define_method(:serialize) do |*args|
             Inferno::Web::Serializers.const_get(self.class.resource_class).render(*args)

data/lib/inferno/apps/web/controllers/requests/show.rb

@@ -3,11 +3,11 @@ module Inferno
     module Controllers
       module Requests
         class Show < Controller
-          def call(params)
-            request = repo.find_full_request(params[:id])
+          def handle(req, res)
+            request = repo.find_full_request(req.params[:id])
             halt 404 if request.nil?
 
-            self.body = serialize(request, view: :full)
+            res.body = serialize(request, view: :full)
           end
         end
       end

data/lib/inferno/apps/web/controllers/test_runs/create.rb

@@ -4,9 +4,9 @@ module Inferno
       module TestRuns
         class Create < Controller
           include Import[
-                    test_sessions_repo: 'repositories.test_sessions',
-                    session_data_repo: 'repositories.session_data',
-                    test_runs_repo: 'repositories.test_runs'
+                    test_sessions_repo: 'inferno.repositories.test_sessions',
+                    session_data_repo: 'inferno.repositories.session_data',
+                    test_runs_repo: 'inferno.repositories.test_runs'
                   ]
 
           PARAMS = [:test_session_id, :test_suite_id, :test_group_id, :test_id].freeze
@@ -42,38 +42,34 @@ module Inferno
             end
           end
 
-          def call(params)
-            test_session = test_sessions_repo.find(params[:test_session_id])
+          def handle(req, res)
+            test_session = test_sessions_repo.find(req.params[:test_session_id])
 
             # if testsession.nil?
             if test_runs_repo.active_test_run_for_session?(test_session.id)
-              self.status = 409
-              self.body = { error: 'Cannot run new test while another test run is in progress' }.to_json
-              return
+              halt 409, { error: 'Cannot run new test while another test run is in progress' }.to_json
             end
 
             verify_runnable(
-              repo.build_entity(create_params(params)).runnable,
-              params[:inputs],
+              repo.build_entity(create_params(req.params)).runnable,
+              req.params[:inputs],
               test_session.suite_options
             )
 
-            test_run = repo.create(create_params(params).merge(status: 'queued'))
+            test_run = repo.create(create_params(req.params).merge(status: 'queued'))
 
-            self.body = serialize(test_run, suite_options: test_session.suite_options)
+            res.body = serialize(test_run, suite_options: test_session.suite_options)
 
-            persist_inputs(params, test_run)
+            persist_inputs(req.params, test_run)
 
             Jobs.perform(Jobs::ExecuteTestRun, test_run.id)
           rescue Sequel::ValidationFailed, Sequel::ForeignKeyConstraintViolation,
                  Inferno::Exceptions::RequiredInputsNotFound,
                  Inferno::Exceptions::NotUserRunnableException => e
-            self.body = { errors: e.message }.to_json
-            self.status = 422
+            halt 422, { errors: e.message }.to_json
           rescue StandardError => e
             Application['logger'].error(e.full_message)
-            self.body = { errors: e.message }.to_json
-            self.status = 500
+            halt 500, { errors: e.message }.to_json
           end
 
           def create_params(params)

data/lib/inferno/apps/web/controllers/test_runs/destroy.rb

@@ -4,21 +4,20 @@ module Inferno
       module TestRuns
         class Destroy < Controller
           include Import[
-                    test_runs_repo: 'repositories.test_runs',
-                    results_repo: 'repositories.results'
+                    test_runs_repo: 'inferno.repositories.test_runs',
+                    results_repo: 'inferno.repositories.results'
                   ]
 
-          def call(params)
-            test_run = test_runs_repo.find(params[:id])
+          def handle(req, res)
+            test_run = test_runs_repo.find(req.params[:id])
 
             if test_run.nil? || ['done', 'cancelling'].include?(test_run.status)
               # If it doesn't exist, already finished, or currently being cancelled
-              self.status = 204
-              return
+              halt 204
             end
 
             test_run_is_waiting = (test_run.status == 'waiting')
-            test_runs_repo.mark_as_cancelling(params[:id])
+            test_runs_repo.mark_as_cancelling(req.params[:id])
 
             if test_run_is_waiting
               waiting_result = results_repo.find_waiting_result(test_run_id: test_run.id)
@@ -26,11 +25,10 @@ module Inferno
               Jobs.perform(Jobs::ResumeTestRun, test_run.id)
             end
 
-            self.status = 204
+            res.status = 204
           rescue StandardError => e
             Application['logger'].error(e.full_message)
-            self.body = { errors: e.message }.to_json
-            self.status = 500
+            halt 500, { errors: e.message }.to_json
           end
         end
       end

data/lib/inferno/apps/web/controllers/test_runs/results/index.rb

@@ -4,11 +4,11 @@ module Inferno
       module TestRuns
         module Results
           class Index < Controller
-            include Import[test_runs_repo: 'repositories.test_runs']
+            include Import[test_runs_repo: 'inferno.repositories.test_runs']
 
-            def call(params)
-              results = test_runs_repo.results_for_test_run(params[:test_run_id])
-              self.body = serialize(results)
+            def handle(req, res)
+              results = test_runs_repo.results_for_test_run(req.params[:test_run_id])
+              res.body = serialize(results)
             end
           end
         end

data/lib/inferno/apps/web/controllers/test_runs/show.rb

@@ -1,26 +1,28 @@
+require_relative '../../serializers/test_run'
+
 module Inferno
   module Web
     module Controllers
       module TestRuns
         class Show < Controller
-          include Import[test_sessions_repo: 'repositories.test_sessions']
+          include Import[test_sessions_repo: 'inferno.repositories.test_sessions']
 
-          def call(params)
-            test_run = repo.find(params[:id])
+          def handle(req, res)
+            test_run = repo.find(req.params[:id])
             halt 404 if test_run.nil?
 
-            if params[:include_results] == 'true'
+            if req.params[:include_results] == 'true'
               results_repo = Inferno::Repositories::Results.new
               test_run.results =
-                if params[:after].present?
-                  results_repo.test_run_results_after(test_run_id: test_run.id, after: Time.parse(params[:after]))
+                if req.params[:after].present?
+                  results_repo.test_run_results_after(test_run_id: test_run.id, after: Time.parse(req.params[:after]))
                 else
                   repo.results_for_test_run(test_run.id)
                 end
             end
 
             test_session = test_sessions_repo.find(test_run.test_session_id)
-            self.body = serialize(test_run, suite_options: test_session.suite_options)
+            res.body = serialize(test_run, suite_options: test_session.suite_options)
           end
         end
       end

data/lib/inferno/apps/web/controllers/test_sessions/create.rb

@@ -1,3 +1,6 @@
+require_relative '../controller'
+require_relative '../../serializers/test_session'
+
 module Inferno
   module Web
     module Controllers
@@ -5,22 +8,20 @@ module Inferno
         class Create < Controller
           PARAMS = [:test_suite_id, :suite_options].freeze
 
-          def call(raw_params)
-            params = raw_params.to_h
-            params.merge!(JSON.parse(request.body.string).symbolize_keys) unless request.body.string.blank?
+          def handle(req, res)
+            params = req.params.to_h
+            params.merge!(JSON.parse(req.body.string).symbolize_keys) unless req.body.string.blank?
 
             session = repo.create(create_params(params))
 
             repo.apply_preset(session.id, params[:preset_id]) if params[:preset_id].present?
 
-            self.body = serialize(session)
+            res.body = serialize(session)
           rescue Sequel::ValidationFailed, Sequel::ForeignKeyConstraintViolation => e
-            self.body = { errors: e.message }.to_json
-            self.status = 422
+            halt 422, { errors: e.message }.to_json
           rescue StandardError => e
             Application['logger'].error(e.full_message)
-            self.body = { errors: e.message }.to_json
-            self.status = 500
+            halt 500, { errors: e.message }.to_json
           end
 
           def create_params(params)

data/lib/inferno/apps/web/controllers/test_sessions/last_test_run.rb

@@ -3,12 +3,12 @@ module Inferno
     module Controllers
       module TestSessions
         class LastTestRun < Controller
-          include Import[test_runs_repo: 'repositories.test_runs']
+          include Import[test_runs_repo: 'inferno.repositories.test_runs']
 
-          def call(params)
-            test_run = test_runs_repo.last_test_run(params[:test_session_id])
+          def handle(req, res)
+            test_run = test_runs_repo.last_test_run(req.params[:id])
 
-            self.body =
+            res.body =
               if test_run.nil?
                 nil
               else

data/lib/inferno/apps/web/controllers/test_sessions/results/index.rb

@@ -4,14 +4,14 @@ module Inferno
       module TestSessions
         module Results
           class Index < Controller
-            include Import[test_sessions_repo: 'repositories.test_sessions']
+            include Import[test_sessions_repo: 'inferno.repositories.test_sessions']
 
-            def call(params)
-              self.body =
-                if params[:all] == 'true'
-                  serialize(test_sessions_repo.results_for_test_session(params[:test_session_id]))
+            def handle(req, res)
+              res.body =
+                if req.params[:all] == 'true'
+                  serialize(test_sessions_repo.results_for_test_session(req.params[:id]))
                 else
-                  serialize(repo.current_results_for_test_session(params[:test_session_id]))
+                  serialize(repo.current_results_for_test_session(req.params[:id]))
                 end
             end
           end

data/lib/inferno/apps/web/controllers/test_sessions/session_data/apply_preset.rb

@@ -1,3 +1,5 @@
+require_relative '../../controller'
+
 module Inferno
   module Web
     module Controllers
@@ -5,35 +7,33 @@ module Inferno
         module SessionData
           class ApplyPreset < Controller
             include Import[
-                      test_sessions_repo: 'repositories.test_sessions',
-                      presets_repo: 'repositories.presets'
+                      test_sessions_repo: 'inferno.repositories.test_sessions',
+                      presets_repo: 'inferno.repositories.presets'
                     ]
 
             def self.resource_class
               'SessionData'
             end
 
-            def call(params)
-              test_session_id = params[:test_session_id]
+            def handle(req, res)
+              test_session_id = req.params[:id]
               test_session = test_sessions_repo.find(test_session_id)
 
               if test_session.nil?
                 Application[:logger].error("Unknown test session #{test_session_id}")
-                self.status = 404
-                return
+                halt 404
               end
 
-              preset_id = params[:preset_id]
+              preset_id = req.params[:preset_id]
               preset = presets_repo.find(preset_id)
 
               if preset.nil?
                 Application[:logger].error("Unknown preset #{preset_id}")
-                self.status = 404
-                return
+                halt 404
               end
 
               test_sessions_repo.apply_preset(test_session_id, preset_id)
-              self.status = 200
+              res.status = 200
             end
           end
         end

data/lib/inferno/apps/web/controllers/test_sessions/session_data/index.rb

@@ -1,17 +1,19 @@
+require_relative '../../../serializers/session_data'
+
 module Inferno
   module Web
     module Controllers
       module TestSessions
         module SessionData
           class Index < Controller
-            include Import[session_data_repo: 'repositories.session_data']
+            include Import[session_data_repo: 'inferno.repositories.session_data']
 
             def self.resource_class
               'SessionData'
             end
 
-            def call(params)
-              self.body = serialize(session_data_repo.get_all_from_session(params[:test_session_id]))
+            def handle(req, res)
+              res.body = serialize(session_data_repo.get_all_from_session(req.params[:id]))
             end
           end
         end

data/lib/inferno/apps/web/controllers/test_sessions/show.rb

@@ -3,11 +3,11 @@ module Inferno
     module Controllers
       module TestSessions
         class Show < Controller
-          def call(params)
-            test_session = repo.find(params[:id])
+          def handle(req, res)
+            test_session = repo.find(req.params[:id])
             halt 404 if test_session.nil?
 
-            self.body = serialize(test_session)
+            res.body = serialize(test_session)
           end
         end
       end

data/lib/inferno/apps/web/controllers/test_suites/check_configuration.rb

@@ -3,11 +3,11 @@ module Inferno
     module Controllers
       module TestSuites
         class CheckConfiguration < Controller
-          def call(params)
-            test_suite = repo.find(params[:id])
+          def handle(req, res)
+            test_suite = repo.find(req.params[:id])
             halt 404 if test_suite.nil?
 
-            self.body =
+            res.body =
               Inferno::Web::Serializers::Message.render(test_suite.configuration_messages(force_recheck: true))
           end
         end

data/lib/inferno/apps/web/controllers/test_suites/index.rb

@@ -3,8 +3,8 @@ module Inferno
     module Controllers
       module TestSuites
         class Index < Controller
-          def call(_params)
-            self.body = serialize(repo.all, view: :summary)
+          def handle(_req, res)
+            res.body = serialize(repo.all, view: :summary)
           end
         end
       end

data/lib/inferno/apps/web/controllers/test_suites/show.rb

@@ -3,11 +3,11 @@ module Inferno
     module Controllers
       module TestSuites
         class Show < Controller
-          def call(params)
-            test_suite = repo.find(params[:id])
+          def handle(req, res)
+            test_suite = repo.find(req.params[:id])
             halt 404 if test_suite.nil?
 
-            self.body = serialize(test_suite, view: :full)
+            res.body = serialize(test_suite, view: :full)
           end
         end
       end

data/lib/inferno/apps/web/index.html.erb

@@ -38,14 +38,18 @@
         height: 100%;
         display: flex;
         flex-direction: column;
+        overflow: hidden;
       }
       .banner {
         flex-shrink: 1;
+        overflow: 'auto';
+        white-space: nowrap;
       }
       .app {
         flex-grow: 1;
         display: flex;
         flex-direction: column;
+        overflow: auto;
       }
     </style>
     <title>Inferno</title>