aspera-cli 4.27.1 → 4.27.3

data/lib/aspera/cli/plugins/orchestrator.rb

@@ -25,7 +25,7 @@ module Aspera
             error = nil
             urls.each do |base_url|
               next unless base_url.match?(%r{^https?://})
-              api = Rest.new(base_url: base_url)
+              api = Rest::Client.new(base_url: base_url)
               data, http = api.read(TEST_ENDPOINT, query: {format: :json}, ret: :both)
               next unless data['remote_orchestrator_info']
               url = http.uri.to_s
@@ -56,17 +56,11 @@ module Aspera
           }
         end
 
-        option :result,      description: "Specify result value as: 'work_step:parameter'"
-        option :synchronous, description: 'Wait for completion', allowed: Type::BOOLEAN, default: false
+        option :result,      description: "Specify result value as: 'work_step:parameter'", deprecation: {last: '4.27.2', message: 'use keys `step` and `variable` of argument `execution` of `workflows start`'}
+        option :synchronous, description: 'Wait for completion', allowed: Type::BOOLEAN, deprecation: {last: '4.27.2', message: 'use key `synchronous` of argument `execution` of `workflows start`'}
         option :ret_style,   description: 'How return type is requested in api', allowed: %i[header arg ext], default: :arg
         option :auth_style,  description: 'Authentication type', allowed: %i[arg_pass head_basic apikey], default: :head_basic
 
-        def initialize(**_)
-          super
-          @api_orch = nil
-          options.parse_options!
-        end
-
         # Call orchestrator API, it's a bit special
         # @param endpoint   [String]  the endpoint to call
         # @param ret_style  [Symbol]  the return style, :header, :arg, :ext(extension)
@@ -90,9 +84,9 @@ module Aspera
             else Aspera.error_unexpected_value(ret_style)
             end
           end
-          add_query = options.get_option(:query)
+          add_query = query_read_delete
           call_args[:query].merge!(add_query.symbolize_keys) unless add_query.nil?
-          data, resp = @api_orch.call(**call_args)
+          data, resp = api_orch.call(**call_args)
           return resp if http
           result = format.eql?('xml') ? XmlSimple.xml_in(resp.body, {'ForceArray' => xml_arrays}) : data
           Log.dump(:data, result)
@@ -103,73 +97,73 @@ module Aspera
 
         # --- DSL ---
 
-        command :health,     description: 'Check Orchestrator API health',               setup: :setup_api
-        command :info,       description: 'Ping the remote Orchestrator instance',       setup: :setup_api, action: -> { Result::SingleObject.new(call_ao('remote_node_ping', format: 'xml', xml_arrays: false)) }
-        command :processes,  description: 'Show Orchestrator background process status', setup: :setup_api, action: -> { Result::ObjectList.new(call_ao('processes_status', format: 'xml')['process']) }
-        command :monitors,   description: 'Show Orchestrator monitor snapshot',          setup: :setup_api, action: -> { Result::SingleObject.new(call_ao('monitor_snapshot')['monitor']) }
-        command :plugins,    description: 'Show Orchestrator plugin versions',           setup: :setup_api, action: -> { Result::ObjectList.new(call_ao('plugin_version')['Plugin']) }
-        command :workflows,  description: 'Manage workflows',   setup: :setup_api
-        command :workorders, description: 'Manage work orders', setup: :setup_api
-        command :workstep,   description: 'Manage work steps',  setup: :setup_api
+        command :health,     description: 'Check Orchestrator API health'
+        command :info,       description: 'Check that Orchestrator responds (ping)', action: ->(**) { Result::SingleObject.new(call_ao('remote_node_ping', format: 'xml', xml_arrays: false)) }
+        command :processes,  description: 'Show Orchestrator background process status', action: ->(**) { Result::ObjectList.new(call_ao('processes_status', format: 'xml')['process']) }
+        command :monitors,   description: 'Show Orchestrator monitor snapshot', action: ->(**) { Result::SingleObject.new(call_ao('monitor_snapshot')['monitor']) }
+        command :plugins,    description: 'Show Orchestrator plugin versions', action: ->(**) { Result::ObjectList.new(call_ao('plugin_version')['Plugin']) }
+        command :workflows,  description: 'Manage workflows'
+        command :workorders, description: 'Manage work orders'
+        command :workstep,   description: 'Manage work steps'
 
         commands_under :workflows do
-          command(:list, description: 'List all workflows', action: lambda do
-            Result::ObjectList.new(
-              call_ao('workflows_list')['workflows']['workflow'],
-              fields: %w[id portable_id name published_status published_revision_id latest_revision_id last_modification]
-            )
-          end)
-          command :status,     description: 'Check running status of workflows',
-            arguments: [{name: :wf_id, type: :identifier}],
-            action: ->(wf_id:, **) { Result::ObjectList.new(call_ao(wf_id.eql?(SpecialValues::ALL) ? 'workflows_status' : "workflows_status/#{wf_id}")['workflows']['workflow']) }
-          command :inputs,     description: 'Fetch input specification for a workflow',
-            arguments: [{name: :wf_id, type: :identifier}],
-            action: ->(wf_id:, **) { Result::SingleObject.new(call_ao("workflow_inputs_spec/#{wf_id}")['workflow_inputs_spec']) }
-          command :details,    description: 'Check detailed running status of a workflow',
-            arguments: [{name: :wf_id, type: :identifier}],
-            action: ->(wf_id:, **) { Result::ObjectList.new(call_ao("workflow_details/#{wf_id}")['workflows']['workflow']['statuses']) }
-          command :start,      description: 'Initiate a work order (sync or async)',
-            arguments: [{name: :wf_id, type: :identifier}, {name: :external_parameters, type: Hash, mandatory: false, default: {}}]
+          command :list, description: 'List all workflows'
+          command :status,     description: 'Show running status of a workflow',
+            arguments: [{name: :workflow_id, type: :identifier}],
+            action: ->(workflow_id:, **) { Result::ObjectList.new(call_ao(workflow_id.eql?(SpecialValues::ALL) ? 'workflows_status' : "workflows_status/#{workflow_id}")['workflows']['workflow']) }
+          command :inputs,     description: 'Show input specification of a workflow',
+            arguments: [{name: :workflow_id, type: :identifier}],
+            action: ->(workflow_id:, **) { Result::SingleObject.new(call_ao("workflow_inputs_spec/#{workflow_id}")['workflow_inputs_spec']) }
+          command :details,    description: 'Show detailed running status of a workflow',
+            arguments: [{name: :workflow_id, type: :identifier}],
+            action: ->(workflow_id:, **) { Result::ObjectList.new(call_ao("workflow_details/#{workflow_id}")['workflows']['workflow']['statuses']) }
+          command :start,      description: 'Start a workflow: create a work order (sync or async)',
+            arguments: [
+              {name: :workflow_id, type: :identifier},
+              {name: :parameters, type: Hash, mandatory: false, default: {}},
+              {name: :execution, type: Hash, mandatory: false, default: {}, schema: 'opts:components.schemas.OrchestratorWorkflowStart'}
+            ]
           command :export,     description: 'Export a workflow',
-            arguments: [{name: :wf_id, type: :identifier}],
-            action: ->(wf_id:, **) { Result::Text.new(call_ao("export_workflow/#{wf_id}", format: nil, http: true).body) }
-          command :workorders, description: 'Fetch all work orders from a workflow',
-            arguments: [{name: :wf_id, type: :identifier}],
-            action: ->(wf_id:, **) { Result::ObjectList.new(call_ao("work_orders_list/#{wf_id}")['work_orders']) }
-          command :outputs,    description: 'Fetch output specification for a workflow',
-            arguments: [{name: :wf_id, type: :identifier}],
-            action: ->(wf_id:, **) { Result::ObjectList.new(call_ao("workflow_outputs_spec/#{wf_id}")['workflow_outputs_spec']['output']) }
+            arguments: [{name: :workflow_id, type: :identifier}],
+            action: ->(workflow_id:, **) { Result::Text.new(call_ao("export_workflow/#{workflow_id}", format: nil, http: true).body) }
+          command :workorders, description: 'List work orders of a workflow',
+            arguments: [{name: :workflow_id, type: :identifier}],
+            action: ->(workflow_id:, **) { Result::ObjectList.new(call_ao("work_orders_list/#{workflow_id}")['work_orders']) }
+          command :outputs,    description: 'Show output specification of a workflow',
+            arguments: [{name: :workflow_id, type: :identifier}],
+            action: ->(workflow_id:, **) { Result::ObjectList.new(call_ao("workflow_outputs_spec/#{workflow_id}")['workflow_outputs_spec']['output']) }
         end
 
         commands_under :workorders do
-          command :status, description: 'Check the status of a work order',
-            arguments: [{name: :wo_id, type: :identifier}],
-            action: ->(wo_id:, **) { Result::SingleObject.new(call_ao("work_order_status/#{wo_id}")['work_order']) }
+          command :status, description: 'Show status of a work order',
+            arguments: [{name: :workorder_id, type: :identifier}],
+            action: ->(workorder_id:, **) { Result::SingleObject.new(call_ao("work_order_status/#{workorder_id}")['work_order']) }
           command :cancel, description: 'Cancel a work order',
-            arguments: [{name: :wo_id, type: :identifier}],
-            action: ->(wo_id:, **) { Result::SingleObject.new(call_ao("work_order_cancel/#{wo_id}")['work_order']) }
+            arguments: [{name: :workorder_id, type: :identifier}],
+            action: ->(workorder_id:, **) { Result::SingleObject.new(call_ao("work_order_cancel/#{workorder_id}")['work_order']) }
           command :reset,  description: 'Reset a work order',
-            arguments: [{name: :wo_id, type: :identifier}],
-            action: ->(wo_id:, **) { Result::SingleObject.new(call_ao("work_order_reset/#{wo_id}")['work_order']) }
-          command :output, description: 'Fetch output of a work order',
-            arguments: [{name: :wo_id, type: :identifier}],
-            action: ->(wo_id:, **) { Result::ObjectList.new(call_ao("work_order_output/#{wo_id}", format: 'xml')['variable']) }
+            arguments: [{name: :workorder_id, type: :identifier}],
+            action: ->(workorder_id:, **) { Result::SingleObject.new(call_ao("work_order_reset/#{workorder_id}")['work_order']) }
+          command :output, description: 'Show output of a work order',
+            arguments: [{name: :workorder_id, type: :identifier}],
+            action: ->(workorder_id:, **) { Result::ObjectList.new(call_ao("work_order_output/#{workorder_id}", format: 'xml')['variable']) }
         end
 
         commands_under :workstep do
-          command :status, description: 'Check the status of a work step',
-            arguments: [{name: :ws_id, type: :identifier}],
-            action: ->(ws_id:, **) { Result::SingleObject.new(call_ao("work_step_status/#{ws_id}")) }
+          command :status, description: 'Show status of a work step',
+            arguments: [{name: :workstep_id, type: :identifier}],
+            action: ->(workstep_id:, **) { Result::SingleObject.new(call_ao("work_step_status/#{workstep_id}")) }
           command :cancel, description: 'Cancel a work step',
-            arguments: [{name: :ws_id, type: :identifier}],
-            action: ->(ws_id:, **) { Result::SingleObject.new(call_ao("work_step_cancel/#{ws_id}")) }
+            arguments: [{name: :workstep_id, type: :identifier}],
+            action: ->(workstep_id:, **) { Result::SingleObject.new(call_ao("work_step_cancel/#{workstep_id}")) }
         end
 
-        # --- setup ---
+        # --- API ---
 
-        # Build the Orchestrator REST API from CLI options.
-        # @return [Hash] ctx with no extra keys (stores api in @api_orch instance var)
-        def setup_api(**)
+        # Orchestrator REST API, built from CLI options on first use.
+        # @return [Rest::Client]
+        def api_orch
+          return @api_orch if @api_orch
           auth_params =
             case options.get_option(:auth_style, mandatory: true)
             when :arg_pass
@@ -189,14 +183,13 @@ module Aspera
             when :apikey
               Aspera.error_not_implemented
             end
-          @api_orch = Rest.new(
+          @api_orch = Rest::Client.new(
             base_url: options.get_option(:url, mandatory: true),
             auth: auth_params
           )
-          {}
         end
 
-        def action_health
+        def action_health(**)
           nagios = Nagios.new
           begin
             info = call_ao('remote_node_ping', format: 'xml', xml_arrays: false)
@@ -209,25 +202,45 @@ module Aspera
         end
 
         # 2.1/2.2 Initiate a workorder (async / synchronous)
-        def action_workflows_start(wf_id:, external_parameters:, **)
+        def action_workflows_list(**)
+          Result::ObjectList.new(
+            call_ao('workflows_list')['workflows']['workflow'],
+            fields: %w[id portable_id name published_status published_revision_id latest_revision_id last_modification]
+          )
+        end
+
+        # Keys of argument `execution` of `workflows start`
+        WORKFLOW_START_KEYS = %w[synchronous step variable].freeze
+        private_constant :WORKFLOW_START_KEYS
+
+        def action_workflows_start(workflow_id:, parameters:, execution:, **)
+          execution = execution.transform_keys(&:to_s)
+          unknown = execution.keys - WORKFLOW_START_KEYS
+          Aspera.assert(unknown.empty?, type: Cli::BadArgument) { "Unknown keys in execution: #{unknown.join(', ')}, expected: #{WORKFLOW_START_KEYS.join(', ')}" }
+          # Deprecated options, used when key not provided
+          execution['synchronous'] = options.get_option(:synchronous) unless execution.key?('synchronous')
+          result_location = options.get_option(:result)
+          unless result_location.nil? || execution.key?('step') || execution.key?('variable')
+            fields = result_location.split(':')
+            Aspera.assert(fields.length == 2, type: Cli::BadArgument) { "Expects: work_step:result_name : #{result_location}" }
+            execution['step'], execution['variable'] = fields
+          end
           call_params = {format: :json}
           # get external parameters if any
-          external_parameters.each do |name, value|
+          parameters.each do |name, value|
             call_params["external_parameters[#{name}]"] = value
           end
-          # synchronous call ?
-          call_params['synchronous'] = true if options.get_option(:synchronous, mandatory: true)
+          Aspera.assert_type(execution['synchronous'], NilClass, *BoolValue::TYPES, type: Cli::BadArgument) { 'synchronous' }
+          call_params['synchronous'] = true if execution['synchronous'].eql?(true)
           # expected result for synchro call ?
-          result_location = options.get_option(:result)
-          unless result_location.nil?
-            fields = result_location.split(':')
-            Aspera.assert(fields.length == 2, type: Cli::BadArgument) { "Expects: work_step:result_name : #{result_location}" }
-            call_params['explicit_output_step'] = fields[0]
-            call_params['explicit_output_variable'] = fields[1]
+          if execution.key?('step') || execution.key?('variable')
+            Aspera.assert(execution['step'].is_a?(String) && execution['variable'].is_a?(String), type: Cli::BadArgument) { 'Both step and variable are required' }
+            call_params['explicit_output_step'] = execution['step']
+            call_params['explicit_output_variable'] = execution['variable']
             # implicitly, call is synchronous
             call_params['synchronous'] = true
           end
-          result_data = call_ao("initiate/#{wf_id}", args: call_params)
+          result_data = call_ao("initiate/#{workflow_id}", args: call_params)
           call_params['synchronous'] ? Result::Text.new(result_data) : Result::SingleObject.new(result_data)
         end
       end

data/lib/aspera/cli/plugins/preview.rb

@@ -18,6 +18,8 @@ require 'aspera/uri_reader'
 require 'aspera/log'
 require 'aspera/assert'
 require 'securerandom'
+require 'aspera/rainbow'
+using Rainbow
 
 module Aspera
   module Cli
@@ -46,21 +48,19 @@ module Aspera
           :LOG_LIMITER_SEC,
           :REMOTE_ACCESS
 
-        attr_accessor :option_skip_types, :option_previews_folder, :option_folder_reset_cache, :option_skip_folders, :option_overwrite
-
-        # DSL option declarations (Pattern 1 and Pattern 2 - handler: Symbol resolved to self)
+        # DSL option declarations
         option :skip_format,        description: 'Skip this preview format',                                                                                                      allowed: Aspera::Preview::Generator::PREVIEW_FORMATS
         # TODO: use the same option as in `node` plugin
-        option :folder_reset_cache, description: 'Force detection of generated preview by refresh cache',                                                                         allowed: %i[no header read], handler: :option_folder_reset_cache, default: :no
-        option :skip_types,         description: 'Skip generation for those types of files',                                                                                      allowed: Type::SYMBOL_ARRAY + Aspera::Preview::FileTypes::CONVERSION_TYPES, handler: :option_skip_types
-        option :previews_folder,    description: 'Preview folder in storage root',                                                                                                handler: :option_previews_folder, default: DEFAULT_PREVIEWS_FOLDER
-        option :skip_folders,       description: 'List of folder to skip',                                                                                                        allowed: Type::STRING_ARRAY, handler: :option_skip_folders
+        option :folder_reset_cache, description: 'Force detection of generated preview by refresh cache',                                                                         allowed: %i[no header read], default: :no
+        option :skip_types,         description: 'Skip generation for those types of files',                                                                                      allowed: Type::SYMBOL_ARRAY + Aspera::Preview::FileTypes::CONVERSION_TYPES
+        option :previews_folder,    description: 'Preview folder in storage root',                                                                                                default: DEFAULT_PREVIEWS_FOLDER
+        option :skip_folders,       description: 'List of folder to skip',                                                                                                        allowed: Type::STRING_ARRAY
         option :base,               description: 'Basename of output for for test'
-        option :filter, description: 'File name filter: String (glob), Regexp, or Proc', allowed: [String, Regexp, Proc, NilClass]
-        option :mimemagic,          description: 'Use Mime type detection of gem mimemagic',                                                                                      allowed: Type::BOOLEAN, default: false
-        option :overwrite,          description: 'When to overwrite result file',                                                                                                 allowed: %i[always never mtime], handler: :option_overwrite, default: :mtime
+        option :filter,             description: 'File name filter: String (glob), Regexp, or Proc', allowed: [String, Regexp, Proc, NilClass]
+        option :detect_mime,        description: 'Detect Mime type by analyzing file', allowed: Type::BOOLEAN, default: false
+        option :overwrite,          description: 'When to overwrite result file', allowed: %i[always never mtime], default: :mtime
         option :root_url,           description: "How to read and write files on storage (#{REMOTE_ACCESS}, or #{UriReader.file_url('<folder>')})", default: REMOTE_ACCESS
-        # Generator-specific options (Category C - bound to @gen_options via set_handler in initialize)
+        # Generator-specific options (bound to @gen_options in initialize)
         Aspera::Preview::Options::DESCRIPTIONS.each do |opt|
           values = if opt.key?(:values)
             opt[:values]
@@ -79,12 +79,20 @@ module Aspera
           # Optional callback used to filter entries before generation.
           @filter_block = nil
           @access_remote = true
-          # Bind generator-specific options to @gen_options (Category C: set_handler after object creation)
+          # Bind generator-specific options to @gen_options
           Aspera::Preview::Options::DESCRIPTIONS.each do |opt|
-            options.set_handler(opt[:name], object: @gen_options, method: opt[:name])
+            options.on_set(opt[:name], @gen_options.method(:"#{opt[:name]}="))
           end
-
+          # Values set through `on_set` callbacks are used below
           options.parse_options!
+          @option_skip_types = options.get_option(:skip_types)
+          @option_previews_folder = options.get_option(:previews_folder)
+          @option_folder_reset_cache = options.get_option(:folder_reset_cache)
+          # Modified during scan
+          @option_skip_folders = options.get_option(:skip_folders).dup
+          @option_overwrite = options.get_option(:overwrite)
+          # Tell which tool we will use for office docs
+          Aspera::Preview::Utils.office_tool = @gen_options.office_conversion
           Api::Node.api_options[:cache] = !@option_folder_reset_cache.eql?(:header)
           # Start from the full supported format list, then remove any skipped format.
           @preview_formats_to_generate = Aspera::Preview::Generator::PREVIEW_FORMATS.clone
@@ -108,7 +116,7 @@ module Aspera
           events_filter['iteration_token'] = iteration_persistency.data.first unless iteration_persistency.nil?
           begin
             events = @api_node.read('events', events_filter)
-          rescue RestCallError => e
+          rescue Rest::CallError => e
             if e.message.include?('Invalid iteration_token')
               Log.log.warn { "Retrying without iteration token: #{e}" }
               events_filter.delete('iteration_token')
@@ -360,7 +368,7 @@ module Aspera
             Log.log.debug { "processing entry #{entry_path_with_slash}" } if @periodic.trigger?
             entry_path_with_slash = "#{entry_path_with_slash}/" unless entry_path_with_slash.end_with?('/')
             if !top_path.nil? && !top_path.start_with?(entry_path_with_slash) && !entry_path_with_slash.start_with?(top_path)
-              Log.log.debug { "#{entry['path']} folder (skip start)".bg_red }
+              Log.log.debug { "#{entry['path']} folder (skip start)".bg(:red) }
               next
             end
             Log.log.debug { "item:#{entry}" }
@@ -376,7 +384,7 @@ module Aspera
                 Log.log.debug('Ignoring link.')
               when 'folder'
                 if @option_skip_folders.include?(entry['path'])
-                  Log.log.debug { "#{entry['path']} folder (skip list)".bg_red }
+                  Log.log.debug { "#{entry['path']} folder (skip list)".bg(:red) }
                 else
                   Log.log.debug { "#{entry['path']} folder".green }
                   # get folder content
@@ -402,14 +410,16 @@ module Aspera
 
         # scan, events and trevents connect to the Node API (setup: :setup_node_api).
         # `check`, `test` and `show` work without Node API authentication.
-        command :scan,     description: 'Scan a file or folder and generate previews',      setup: :setup_node_api, arguments: [{name: :path, type: String, description: 'File or folder from which to start scanning', mandatory: false, default: '/'}]
-        command :events,   description: 'Process file events and generate previews',        setup: :setup_node_api
-        command :trevents, description: 'Process transfer events and generate previews',    setup: :setup_node_api
-        command :check,    description: 'Check required tools are installed'
-        command :show,     description: 'Generate and display preview of a source file', arguments: [{name: :source_file, type: String, description: 'Local file to preview'}]
+        command :scan,     description: 'Scan a file or folder and generate previews', setup: :setup_node_api,
+          arguments: [{name: :path, description: 'File or folder from which to start scanning', mandatory: false, default: '/'}]
+        command :events,   description: 'Process file events and generate previews',        setup: :setup_node_api, action: ->(**) { run_event_loop(:events) }
+        command :trevents, description: 'Process transfer events and generate previews',    setup: :setup_node_api, action: ->(**) { run_event_loop(:trevents) }
+        command :check,    description: 'Check required tools are installed', action: ->(**) { tools_cleanup { Result::Status.new('Tools validated') } }
+        command :show,     description: 'Generate and display preview of a source file',
+          arguments: [{name: :source_file, description: 'Local file to preview'}]
         command :test,     description: 'Test preview generation for a source file',
           arguments: [
-            {name: :source_file, type: String, description: 'Local file to preview'},
+            {name: :source_file, description: 'Local file to preview'},
             {name: :format, description: 'Preview output format', allowed: Aspera::Preview::Generator::PREVIEW_FORMATS, mandatory: false, default: :png}
           ]
 
@@ -461,71 +471,47 @@ module Aspera
         # --- handlers ---
 
         def action_scan(path:, **)
-          check_tools_and_mimemagic
-          apifid =
-            if (selector = Parser.percent_selector(path))
-              Aspera.assert_values(selector[:field], ['id'], type: BadArgument) { 'file id' }
-              Api::NodeFileId.new(@api_node, selector[:value].to_s.empty? ? @access_key_self['root_file_id'] : selector[:value])
-            else
-              @api_node.resolve_api_fid(@access_key_self['root_file_id'], path)
-            end
-          @filter_block = Base.file_matcher(options.get_option(:filter))
-          scan_folder_files(@api_node.read("files/#{apifid.file_id}"))
-          Result::Status.new('scan finished')
-        ensure
-          cleanup_tmp_folder
-        end
-
-        def action_events(**)
-          check_tools_and_mimemagic
-          run_event_loop(:events, filter: options.get_option(:filter))
-        ensure
-          cleanup_tmp_folder
-        end
-
-        def action_trevents(**)
-          check_tools_and_mimemagic
-          run_event_loop(:trevents, filter: options.get_option(:filter))
-        ensure
-          cleanup_tmp_folder
+          tools_cleanup do
+            apifid =
+              if (selector = Parser.percent_selector(path))
+                Aspera.assert_values(selector[:field], ['id'], type: BadArgument) { 'file id' }
+                Api::NodeFileId.new(@api_node, selector[:value].to_s.empty? ? @access_key_self['root_file_id'] : selector[:value])
+              else
+                @api_node.resolve_api_fid(@access_key_self['root_file_id'], path)
+              end
+            @filter_block = Base.file_matcher(options.get_option(:filter))
+            scan_folder_files(@api_node.read("files/#{apifid.file_id}"))
+            Result::Status.new('scan finished')
+          end
         end
 
-        def action_check
-          check_tools_and_mimemagic
-          Result::Status.new('Tools validated')
-        ensure
-          cleanup_tmp_folder
-        end
+        # Status message for generation
+        MSG_GEN_TITLE = 'Generated: '
 
         def action_test(source_file:, format:, **)
-          check_tools_and_mimemagic
-          generated_file_path = preview_filename(format, options.get_option(:base))
-          Aspera::Preview::Generator.new(source_file, generated_file_path, @gen_options, @tmp_folder).generate
-          Result::Status.new("generated: #{generated_file_path}")
-        ensure
-          cleanup_tmp_folder
+          tools_cleanup do
+            generated_file_path = preview_filename(format, options.get_option(:base))
+            Aspera::Preview::Generator.new(source_file, generated_file_path, @gen_options, @tmp_folder).generate
+            Result::Status.new("#{MSG_GEN_TITLE}#{generated_file_path}")
+          end
         end
 
         def action_show(source_file:, **)
-          check_tools_and_mimemagic
-          generated_file_path = preview_filename(:png, options.get_option(:base))
-          Aspera::Preview::Generator.new(source_file, generated_file_path, @gen_options, @tmp_folder).generate
-          formatter.display_status("generated: #{generated_file_path}")
+          status = action_test(source_file: source_file, format: :png)
+          formatter.display_status(status.data)
+          generated_file_path = status.data.delete_prefix(MSG_GEN_TITLE)
           Result::Image.new(UriReader.file_url(generated_file_path))
-        ensure
-          cleanup_tmp_folder
         end
 
         private
 
-        # Check tools and set mimemagic flag (required for all commands).
-        def check_tools_and_mimemagic
-          Aspera::Preview::FileTypes.instance.use_mimemagic = options.get_option(:mimemagic, mandatory: true)
-          Aspera::Preview::Utils.check_tools(@option_skip_types)
-        end
-
+        # Check tools and set option flag.
         # Clean up the temporary folder after each command.
-        def cleanup_tmp_folder
+        def tools_cleanup
+          Aspera::Preview::FileTypes.instance.detect_mime = options.get_option(:detect_mime, mandatory: true)
+          Aspera::Preview::Utils.check_tools(@option_skip_types)
+          yield
+        ensure
           Log.log.debug { "cleaning up temp folder #{@tmp_folder}" }
           FileUtils.rm_rf(@tmp_folder)
         end
@@ -533,23 +519,26 @@ module Aspera
         # Shared event-loop body for :events and :trevents.
         # @param command [:events, :trevents]
         # @param filter  [String, Regexp, Proc, nil] optional filter expression
-        def run_event_loop(command, filter: nil)
-          @filter_block = Base.file_matcher(filter)
-          iteration_persistency = nil
-          if options.get_option(:once_only, mandatory: true)
-            iteration_persistency = PersistencyActionOnce.new(
-              manager: persistency,
-              data:    [],
-              id:      IdGenerator.from_list(
-                'preview_iteration',
-                command.to_s,
-                options.get_option(:url, mandatory: true),
-                options.get_option(:username, mandatory: true)
+        def run_event_loop(command)
+          tools_cleanup do
+            filter = options.get_option(:filter)
+            @filter_block = Base.file_matcher(filter)
+            iteration_persistency = nil
+            if options.get_option(:once_only, mandatory: true)
+              iteration_persistency = PersistencyActionOnce.new(
+                manager: persistency,
+                data:    [],
+                id:      IdGenerator.from_list(
+                  'preview_iteration',
+                  command.to_s,
+                  options.get_option(:url, mandatory: true),
+                  options.get_option(:username, mandatory: true)
+                )
               )
-            )
+            end
+            send(:"process_#{command}", iteration_persistency)
+            Result::Status.new("#{command} finished")
           end
-          send(:"process_#{command}", iteration_persistency)
-          Result::Status.new("#{command} finished")
         end
       end
     end