inferno_core 1.1.2 → 1.2.0

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

@@ -3,15 +3,23 @@ require_relative 'evaluate'
 require_relative 'migration'
 require_relative 'requirements'
 require_relative 'services'
+require_relative 'session_commands'
 require_relative 'suite'
 require_relative 'suites'
 require_relative 'new'
 require_relative 'execute'
+require_relative 'execute_script'
 require_relative '../../version'
 
 module Inferno
   module CLI
     class Main < Thor
+      def initialize(args = [], local_options = {}, config = {})
+        super
+        return unless @options[:inferno_base_url]
+
+        @options = @options.merge(inferno_base_url: "#{@options[:inferno_base_url].delete_suffix('/')}/")
+      end
       desc 'evaluate', 'Run a FHIR Data Evaluator.'
       long_desc <<-LONGDESC
         Evaluate FHIR data in the context of a given Implementation Guide,
@@ -70,6 +78,44 @@ module Inferno
       desc 'requirements SUBCOMMAND ...ARGS', 'Perform requirements operations'
       subcommand 'requirements', Requirements
 
+      desc 'execute_script YAML_FILE',
+           'Run a session orchestration script defined by a YAML config file.'
+      option :inferno_base_url,
+             aliases: ['-I'],
+             type: :string,
+             desc: 'URL of the target Inferno service.'
+      option :compare_messages,
+             aliases: ['-m'],
+             type: :boolean,
+             default: true,
+             desc: 'Compare messages array when comparing results.'
+      option :compare_result_message,
+             aliases: ['-r'],
+             type: :boolean,
+             default: true,
+             desc: 'Compare result_message field when comparing results.'
+      option :poll_interval,
+             aliases: ['-p'],
+             type: :numeric,
+             default: 3,
+             desc: 'Seconds between status polls.'
+      option :default_poll_timeout,
+             aliases: ['-t'],
+             type: :numeric,
+             default: 120,
+             desc: 'Default seconds to wait for a matching step before timing out.'
+      option :allow_commands,
+             type: :boolean,
+             default: false,
+             desc: 'Allow execution script steps that run arbitrary shell commands. ' \
+                   'Scripts with command: steps will fail unless this flag is set.'
+      def execute_script(yaml_file)
+        ExecuteScript.new(yaml_file, options).run
+      end
+
+      desc 'session SUBCOMMAND ...ARGS', 'Perform session operations'
+      subcommand 'session', Session::SessionCommands
+
       desc 'start', 'Start Inferno'
       option :watch,
              default: false,

data/lib/inferno/apps/cli/session/cancel_run.rb

@@ -0,0 +1,47 @@
+require 'faraday'
+require_relative 'connection'
+require_relative 'errors'
+require_relative 'session_status'
+
+module Inferno
+  module CLI
+    module Session
+      class CancelRun
+        include Connection
+        include Errors
+
+        attr_accessor :session_id, :options
+
+        CANCELLABLE_STATUSES = %w[queued running waiting].freeze
+
+        def initialize(session_id, options)
+          self.session_id = session_id
+          self.options = options
+        end
+
+        def run
+          puts JSON.pretty_generate(cancel_run(last_test_run))
+          exit(0)
+        end
+
+        def cancel_run(current_run)
+          run_id = current_run['id']
+
+          unless CANCELLABLE_STATUSES.include?(current_run['status'])
+            error = { errors: "Run '#{run_id}' cannot be cancelled: status is '#{current_run['status']}'" }
+            puts JSON.pretty_generate(error)
+            exit(3)
+          end
+
+          response = delete("api/test_runs/#{run_id}")
+          handle_web_api_error(response, :cancel_run) if response.status != 204
+          { run_id: run_id, cancelled: true }
+        end
+
+        def last_test_run
+          SessionStatus.new(session_id, options).last_test_run
+        end
+      end
+    end
+  end
+end

data/lib/inferno/apps/cli/session/connection.rb

@@ -0,0 +1,47 @@
+module Inferno
+  module CLI
+    module Session
+      module Connection
+        def connection
+          @connection ||= Faraday.new(
+            base_url,
+            request: { timeout: 600 }
+          )
+        end
+
+        def base_url
+          @base_url ||=
+            "#{(options[:inferno_base_url].presence || Inferno::Application['base_url']).to_s.delete_suffix('/')}/"
+        end
+
+        def get(path, params = nil, headers = {})
+          connection.get(path, params, headers)
+        rescue Faraday::Error => e
+          handle_connection_error(e)
+        end
+
+        def post(path, body = nil, headers = {})
+          connection.post(path, body, headers)
+        rescue Faraday::Error => e
+          handle_connection_error(e)
+        end
+
+        def delete(path, params = nil, headers = {})
+          connection.delete(path, params, headers)
+        rescue Faraday::Error => e
+          handle_connection_error(e)
+        end
+
+        def handle_connection_error(error)
+          puts JSON.pretty_generate({ errors: "Could not connect to Inferno at '#{base_url}': #{error.message}" })
+          exit(3)
+        end
+
+        def check_session_exists
+          response = get("api/test_sessions/#{session_id}", nil, content_type: 'application/json')
+          handle_web_api_error(response, :session_details) if response.status != 200
+        end
+      end
+    end
+  end
+end

data/lib/inferno/apps/cli/session/create_session.rb

@@ -0,0 +1,159 @@
+require 'faraday'
+require_relative 'connection'
+require_relative 'errors'
+
+module Inferno
+  module CLI
+    module Session
+      class CreateSession
+        include Connection
+        include Errors
+
+        COMMAND_OPTIONS = {
+          suite_options: {
+            aliases: ['-o'],
+            type: :hash,
+            desc: 'Suite options used to initialize the session.'
+          },
+          preset: {
+            aliases: ['-p'],
+            type: :string,
+            desc: 'Preset to apply when creating the session (internal ID or title).'
+          }
+        }.freeze
+
+        attr_accessor :options
+        attr_reader :suite
+
+        def initialize(suite, options)
+          @suite = suite
+          self.options = options
+        end
+
+        def run
+          puts JSON.pretty_generate(create_session)
+          exit(0)
+        end
+
+        def create_session
+          request_body = { test_suite_id: suite_id }
+          request_body[:preset_id] = preset_id if options[:preset].present?
+          request_body[:suite_options] = suite_options_list if options[:suite_options].present?
+
+          response = post('api/test_sessions', request_body.to_json, content_type: 'application/json')
+
+          handle_web_api_error(response, :session_create) if response.status != 200
+
+          JSON.parse(response.body)
+        end
+
+        def suite_id
+          @suite_id ||= resolve_suite_identifier
+        end
+
+        def all_suite_definitions
+          @all_suite_definitions ||= begin
+            response = get('api/test_suites')
+            if response.status != 200
+              puts JSON.pretty_generate({ errors: "Could not fetch test suites list from '#{base_url}'" })
+              exit(3)
+            end
+            JSON.parse(response.body)
+          end
+        end
+
+        def resolve_suite_identifier
+          matched = all_suite_definitions.find { |s| s['id'] == suite }
+          return matched['id'] if matched.present?
+
+          matched = all_suite_definitions.find { |s| s['title'] == suite || s['short_title'] == suite }
+          return matched['id'] if matched.present?
+
+          valid_suites = all_suite_definitions.map { |s| "#{s['id']} (#{s['title']})" }.join(', ')
+          puts JSON.pretty_generate(
+            { errors: "Suite '#{suite}' not found. Valid suites: #{valid_suites}" }
+          )
+          exit(3)
+        end
+
+        def preset_id
+          @preset_id ||= resolve_preset_identifier
+        end
+
+        def suite_presets
+          suite_def = all_suite_definitions.find { |s| s['id'] == suite_id }
+          suite_def&.fetch('presets', []) || []
+        end
+
+        def resolve_preset_identifier
+          return unless options[:preset].present?
+
+          preset = options[:preset]
+          return preset if suite_presets.any? { |p| p['id'] == preset }
+
+          matched = suite_presets.find { |p| p['title'] == preset }
+          return matched['id'] if matched.present?
+
+          valid_presets = suite_presets.map { |p| "#{p['id']} (#{p['title']})" }.join(', ')
+          puts JSON.pretty_generate(
+            { errors: "Preset '#{preset}' not found for suite '#{suite_id}'. Valid presets: #{valid_presets}" }
+          )
+          exit(3)
+        end
+
+        def suite_option_definitions
+          suite_def = all_suite_definitions.find { |s| s['id'] == suite_id }
+          suite_def&.fetch('suite_options', []) || []
+        end
+
+        def suite_options_list
+          options[:suite_options].keys.map do |option_key|
+            option_id = resolve_suite_option_key(option_key)
+            { id: option_id, value: resolve_suite_option_value(option_id, options[:suite_options][option_key]) }
+          end
+        end
+
+        def resolve_suite_option_key(option_key)
+          return option_key if suite_option_definitions.any? { |d| d['id'] == option_key }
+
+          matched = suite_option_definitions.find { |d| d['title'] == option_key }
+          return matched['id'] if matched.present?
+
+          valid_options = suite_option_definitions.map { |d| "#{d['id']} (#{d['title']})" }.join(', ')
+          puts JSON.pretty_generate({
+                                      errors: "Unknown suite option '#{option_key}' for suite '#{suite_id}'. " \
+                                              "Valid options: #{valid_options}"
+                                    })
+          exit(3)
+        end
+
+        def resolve_suite_option_value(option_id, provided_value)
+          provided_value = provided_value.to_s
+          list_options = suite_option_list_options(option_id)
+
+          return provided_value if list_options.blank?
+          return provided_value if list_options.any? { |o| o['value'] == provided_value }
+
+          resolve_suite_option_value_by_label(option_id, provided_value, list_options)
+        end
+
+        def suite_option_list_options(option_id)
+          definition = suite_option_definitions.find { |d| d['id'] == option_id }
+          definition&.fetch('list_options', nil)
+        end
+
+        def resolve_suite_option_value_by_label(option_id, provided_value, list_options)
+          matched = list_options.find { |o| o['label'] == provided_value }
+          return matched['value'] if matched
+
+          valid_options = list_options.map { |o| "#{o['value']} (#{o['label']})" }.join(', ')
+          puts JSON.pretty_generate({
+                                      errors: "Invalid value '#{provided_value}' for suite option '#{option_id}'. " \
+                                              "Valid values: #{valid_options}"
+                                    })
+          exit(3)
+        end
+      end
+    end
+  end
+end

data/lib/inferno/apps/cli/session/errors.rb

@@ -0,0 +1,45 @@
+module Inferno
+  module CLI
+    module Session
+      module Errors
+        def handle_web_api_error(response, api = nil)
+          error = parse_error_response(response, api)
+          puts JSON.pretty_generate(error)
+          exit(3)
+        end
+
+        def parse_error_response(response, api)
+          JSON.parse(response.body)
+        rescue JSON::ParserError
+          { errors: text_error_message(response, api) }
+        end
+
+        def text_error_message(response, api)
+          if response.body == 'Not Found' || response.status == 404
+            not_found_error_message(api)
+          elsif api == :test_run_results && response.status == 500
+            test_run_not_found_message(response)
+          else
+            response.body
+          end
+        end
+
+        def not_found_error_message(api)
+          case api
+          when :session_create, :run_create
+            "Running Inferno host not found at '#{base_url}'"
+          when :session_details, :session_data, :last_session_run
+            "Session '#{session_id}' not found on Inferno host at '#{base_url}'"
+          else
+            'Not Found'
+          end
+        end
+
+        def test_run_not_found_message(response)
+          test_run_id = response.env.url.to_s.split('/')[-2]
+          "Test Run '#{test_run_id}' for session '#{session_id}' not found on Inferno host at '#{base_url}'"
+        end
+      end
+    end
+  end
+end