aspera-cli 4.6.0 → 4.7.0

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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'aspera/cli/plugins/node'
 require 'xmlsimple'
 
@@ -7,47 +8,47 @@ module Aspera
       class Orchestrator < BasicAuthPlugin
         def initialize(env)
           super(env)
-          self.options.add_opt_simple(:params,"parameters hash table, use @json:{\"param\":\"value\"}")
-          self.options.add_opt_simple(:result,"specify result value as: 'work step:parameter'")
-          self.options.add_opt_boolean(:synchronous,"work step:parameter expected as result")
-          self.options.add_opt_list(:ret_style,[:header,:arg,:ext],'how return type is requested in api')
-          self.options.add_opt_list(:auth_style,[:arg_pass,:head_basic,:apikey],'authentication type')
-          self.options.set_option(:params,{})
-          self.options.set_option(:synchronous,:no)
-          self.options.set_option(:ret_style,:arg)
-          self.options.set_option(:auth_style,:head_basic)
-          self.options.parse_options!
+          options.add_opt_simple(:params,'parameters hash table, use @json:{"param":"value"}')
+          options.add_opt_simple(:result,"specify result value as: 'work step:parameter'")
+          options.add_opt_boolean(:synchronous,'work step:parameter expected as result')
+          options.add_opt_list(:ret_style,[:header,:arg,:ext],'how return type is requested in api')
+          options.add_opt_list(:auth_style,[:arg_pass,:head_basic,:apikey],'authentication type')
+          options.set_option(:params,{})
+          options.set_option(:synchronous,:no)
+          options.set_option(:ret_style,:arg)
+          options.set_option(:auth_style,:head_basic)
+          options.parse_options!
         end
 
-        ACTIONS=[:info, :workflow, :plugins, :processes]
+        ACTIONS=[:info, :workflow, :plugins, :processes].freeze
 
         # for JSON format: add extension ".json" or add url parameter: format=json or Accept: application/json
         # id can be: a parameter id=x, or at the end of url /id, for workflows: work_order[workflow_id]=wf_id
-        def call_API_orig(endpoint,id=nil,url_params={:format=>:json},accept=nil)
-          # calls are GET
-          call_args={:operation=>'GET',:subpath=>endpoint}
-          # specify id if necessary
-          call_args[:subpath]=call_args[:subpath]+'/'+id unless id.nil?
-          unless url_params.nil?
-            if url_params.has_key?(:format)
-              call_args[:headers]={'Accept'=>'application/'+url_params[:format].to_s}
-            end
-            call_args[:headers]={'Accept'=>accept} unless accept.nil?
-            # add params if necessary
-            call_args[:url_params]=url_params
-          end
-          return @api_orch.call(call_args)
-        end
+        #        def call_API_orig(endpoint,id=nil,url_params={format: :json},accept=nil)
+        #          # calls are GET
+        #          call_args={operation: 'GET',subpath: endpoint}
+        #          # specify id if necessary
+        #          call_args[:subpath]=call_args[:subpath]+'/'+id unless id.nil?
+        #          unless url_params.nil?
+        #            if url_params.has_key?(:format)
+        #              call_args[:headers]={'Accept'=>'application/'+url_params[:format].to_s}
+        #            end
+        #            call_args[:headers]={'Accept'=>accept} unless accept.nil?
+        #            # add params if necessary
+        #            call_args[:url_params]=url_params
+        #          end
+        #          return @api_orch.call(call_args)
+        #        end
 
-        def call_API(endpoint,opt={})
+        def call_ao(endpoint,opt={})
           opt[:prefix]='api' unless opt.has_key?(:prefix)
           # calls are GET
-          call_args={:operation=>'GET',:subpath=>endpoint}
+          call_args={operation: 'GET',subpath: endpoint}
           # specify prefix if necessary
           call_args[:subpath]="#{opt[:prefix]}/#{call_args[:subpath]}" unless opt[:prefix].nil?
           # specify id if necessary
           call_args[:subpath]="#{call_args[:subpath]}/#{opt[:id]}" if opt.has_key?(:id)
-          call_type=self.options.get_option(:ret_style,:mandatory)
+          call_type=options.get_option(:ret_style,:mandatory)
           call_type=opt[:ret_style] if opt.has_key?(:ret_style)
           format='json'
           format=opt[:format] if opt.has_key?(:format)
@@ -61,82 +62,83 @@ module Aspera
               call_args[:url_params][:format]=format
             when :ext
               call_args[:subpath]="#{call_args[:subpath]}.#{format}"
-            else raise "unexpected"
+            else raise 'unexpected'
             end
           end
           result=@api_orch.call(call_args)
-          result[:data]=XmlSimple.xml_in(result[:http].body, opt[:xml_opt]||{"ForceArray" => true}) if format.eql?('xml')
+          result[:data]=XmlSimple.xml_in(result[:http].body, opt[:xml_opt]||{'ForceArray' => true}) if format.eql?('xml')
           return result
         end
 
         def execute_action
-          rest_params={:base_url       => self.options.get_option(:url,:mandatory)}
-          case self.options.get_option(:auth_style,:mandatory)
+          rest_params={base_url: options.get_option(:url,:mandatory)}
+          case options.get_option(:auth_style,:mandatory)
           when :arg_pass
             rest_params[:auth]={
-              :type      => :url,
-              :url_creds => {
-              'login'      =>self.options.get_option(:username,:mandatory),
-              'password'   =>self.options.get_option(:password,:mandatory) }}
+              type:       :url,
+              url_creds:  {
+              'login'      =>options.get_option(:username,:mandatory),
+              'password'   =>options.get_option(:password,:mandatory) }}
           when :head_basic
             rest_params[:auth]={
-              :type      => :basic,
-              :username  =>self.options.get_option(:username,:mandatory),
-              :password  =>self.options.get_option(:password,:mandatory) }
+              type:       :basic,
+              username:   options.get_option(:username,:mandatory),
+              password:   options.get_option(:password,:mandatory) }
           when :apikey
-            raise "Not implemented"
+            raise 'Not implemented'
           end
 
           @api_orch=Rest.new(rest_params)
 
-          command1=self.options.get_next_command(ACTIONS)
+          command1=options.get_next_command(ACTIONS)
           case command1
           when :info
-            result=call_API('remote_node_ping',format: 'xml', xml_opt: {"ForceArray" => false})
-            return {:type=>:single_object,:data=>result[:data]}
-            #            result=call_API('workflows',prefix: nil,format: nil)
+            result=call_ao('remote_node_ping',format: 'xml', xml_opt: {'ForceArray' => false})
+            return {type: :single_object,data: result[:data]}
+            #            result=call_ao('workflows',prefix: nil,format: nil)
             #            version='unknown'
             #            if m=result[:http].body.match(/\(Orchestrator v([1-9]+\.[\.0-9a-f\-]+)\)/)
             #              version=m[1]
             #            end
-            #            return {:type=>:single_object,:data=>{'version'=>version}}
+            #            return {type: :single_object,data: {'version'=>version}}
           when :processes
             # TODO: Jira ? API has only XML format
-            result=call_API('processes_status',format: 'xml')
-            return {:type=>:object_list,:data=>result[:data]['process']}
+            result=call_ao('processes_status',format: 'xml')
+            return {type: :object_list,data: result[:data]['process']}
           when :plugins
             # TODO: Jira ? only json format on url
-            result=call_API('plugin_version')[:data]
-            return {:type=>:object_list,:data=>result['Plugin']}
+            result=call_ao('plugin_version')[:data]
+            return {type: :object_list,data: result['Plugin']}
           when :workflow
-            command=self.options.get_next_command([:list, :status, :inputs, :details, :start, :export])
+            command=options.get_next_command([:list, :status, :inputs, :details, :start, :export])
             unless [:list].include?(command)
-              wf_id=self.instance_identifier()
+              wf_id=instance_identifier()
             end
             case command
             when :status
               options={}
               options[:id]=wf_id unless wf_id.eql?('ALL')
-              result=call_API('workflows_status',options)[:data]
-              return {:type=>:object_list,:data=>result['workflows']['workflow']}
+              result=call_ao('workflows_status',options)[:data]
+              return {type: :object_list,data: result['workflows']['workflow']}
             when :list
-              result=call_API('workflows_list',id: 0)[:data]
-              return {:type=>:object_list,:data=>result['workflows']['workflow'],:fields=>["id","portable_id","name","published_status","published_revision_id","latest_revision_id","last_modification"]}
+              result=call_ao('workflows_list',id: 0)[:data]
+              return {type: :object_list,data: result['workflows']['workflow'],
+fields: ['id','portable_id','name','published_status','published_revision_id','latest_revision_id','last_modification']}
             when :details
-              result=call_API('workflow_details',id: wf_id)[:data]
-              return {:type=>:object_list,:data=>result['workflows']['workflow']['statuses']}
+              result=call_ao('workflow_details',id: wf_id)[:data]
+              return {type: :object_list,data: result['workflows']['workflow']['statuses']}
             when :inputs
-              result=call_API('workflow_inputs_spec',id: wf_id)[:data]
-              return {:type=>:single_object,:data=>result['workflow_inputs_spec']}
+              result=call_ao('workflow_inputs_spec',id: wf_id)[:data]
+              return {type: :single_object,data: result['workflow_inputs_spec']}
             when :export
-              result=call_API('export_workflow',id: wf_id,format: nil)[:http]
-              return {:type=>:text,:data=>result.body}
+              result=call_ao('export_workflow',id: wf_id,format: nil)[:http]
+              return {type: :text,data: result.body}
             when :start
               result={
-                :type=>:single_object,
-                :data=>nil
+                type: :single_object,
+                data: nil
               }
-              call_params={:format=>:json}
+              call_params={format: :json}
               override_accept=nil
               # set external parameters if any
               self.options.get_option(:params,:mandatory).each do |name,value|
@@ -159,7 +161,7 @@ module Aspera
                 result[:type]=:text
                 override_accept='text/plain'
               end
-              result[:data]=call_API('initiate',id: wf_id,args: call_params,accept: override_accept)[:data]
+              result[:data]=call_ao('initiate',id: wf_id,args: call_params,accept: override_accept)[:data]
               return result
             end # wf command
           else raise "ERROR, unknown command: [#{command}]"

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

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
 require 'aspera/cli/basic_auth_plugin'
 require 'aspera/preview/generator'
 require 'aspera/preview/options'
 require 'aspera/preview/utils'
 require 'aspera/preview/file_types'
+require 'aspera/fasp/transfer_spec'
 require 'aspera/persistency_action_once'
 require 'aspera/node'
 require 'aspera/hash_ext'
@@ -31,10 +33,7 @@ module Aspera
 
         # option_skip_format has special accessors
         attr_accessor :option_previews_folder
-        attr_accessor :option_folder_reset_cache
-        attr_accessor :option_skip_folders
-        attr_accessor :option_overwrite
-        attr_accessor :option_file_access
+        attr_accessor :option_folder_reset_cache, :option_skip_folders, :option_overwrite, :option_file_access
         def initialize(env)
           super(env)
           @skip_types=[]
@@ -46,43 +45,43 @@ module Aspera
           # used to trigger periodic processing
           @periodic=TimerLimiter.new(LOG_LIMITER_SEC)
           # link CLI options to gen_info attributes
-          self.options.set_obj_attr(:skip_format,self,:option_skip_format,[]) # no skip
-          self.options.set_obj_attr(:folder_reset_cache,self,:option_folder_reset_cache,:no)
-          self.options.set_obj_attr(:skip_types,self,:option_skip_types)
-          self.options.set_obj_attr(:previews_folder,self,:option_previews_folder,DEFAULT_PREVIEWS_FOLDER)
-          self.options.set_obj_attr(:skip_folders,self,:option_skip_folders,[]) # no skip
-          self.options.set_obj_attr(:overwrite,self,:option_overwrite,:mtime)
-          self.options.set_obj_attr(:file_access,self,:option_file_access,:local)
-          self.options.add_opt_list(:skip_format,Aspera::Preview::Generator::PREVIEW_FORMATS,'skip this preview format (multiple possible)')
-          self.options.add_opt_list(:folder_reset_cache,[:no,:header,:read],'force detection of generated preview by refresh cache')
-          self.options.add_opt_simple(:skip_types,'skip types in comma separated list')
-          self.options.add_opt_simple(:previews_folder,'preview folder in storage root')
-          self.options.add_opt_simple(:temp_folder,'path to temp folder')
-          self.options.add_opt_simple(:skip_folders,'list of folder to skip')
-          self.options.add_opt_simple(:case,'basename of output for for test')
-          self.options.add_opt_simple(:scan_path,'subpath in folder id to start scan in (default=/)')
-          self.options.add_opt_simple(:scan_id,'forder id in storage to start scan in, default is access key main folder id')
-          self.options.add_opt_boolean(:mimemagic,'use Mime type detection of gem mimemagic')
-          self.options.add_opt_list(:overwrite,[:always,:never,:mtime],'when to overwrite result file')
-          self.options.add_opt_list(:file_access,[:local,:remote],'how to read and write files in repository')
-          self.options.set_option(:temp_folder,Dir.tmpdir)
-          self.options.set_option(:mimemagic,:false)
+          options.set_obj_attr(:skip_format,self,:option_skip_format,[]) # no skip
+          options.set_obj_attr(:folder_reset_cache,self,:option_folder_reset_cache,:no)
+          options.set_obj_attr(:skip_types,self,:option_skip_types)
+          options.set_obj_attr(:previews_folder,self,:option_previews_folder,DEFAULT_PREVIEWS_FOLDER)
+          options.set_obj_attr(:skip_folders,self,:option_skip_folders,[]) # no skip
+          options.set_obj_attr(:overwrite,self,:option_overwrite,:mtime)
+          options.set_obj_attr(:file_access,self,:option_file_access,:local)
+          options.add_opt_list(:skip_format,Aspera::Preview::Generator::PREVIEW_FORMATS,'skip this preview format (multiple possible)')
+          options.add_opt_list(:folder_reset_cache,[:no,:header,:read],'force detection of generated preview by refresh cache')
+          options.add_opt_simple(:skip_types,'skip types in comma separated list')
+          options.add_opt_simple(:previews_folder,'preview folder in storage root')
+          options.add_opt_simple(:temp_folder,'path to temp folder')
+          options.add_opt_simple(:skip_folders,'list of folder to skip')
+          options.add_opt_simple(:case,'basename of output for for test')
+          options.add_opt_simple(:scan_path,'subpath in folder id to start scan in (default=/)')
+          options.add_opt_simple(:scan_id,'forder id in storage to start scan in, default is access key main folder id')
+          options.add_opt_boolean(:mimemagic,'use Mime type detection of gem mimemagic')
+          options.add_opt_list(:overwrite,[:always,:never,:mtime],'when to overwrite result file')
+          options.add_opt_list(:file_access,[:local,:remote],'how to read and write files in repository')
+          options.set_option(:temp_folder,Dir.tmpdir)
+          options.set_option(:mimemagic,false)
 
           # add other options for generator (and set default values)
           Aspera::Preview::Options::DESCRIPTIONS.each do |opt|
-            self.options.set_obj_attr(opt[:name],@gen_options,opt[:name],opt[:default])
+            options.set_obj_attr(opt[:name],@gen_options,opt[:name],opt[:default])
             if opt.has_key?(:values)
-              self.options.add_opt_list(opt[:name],opt[:values],opt[:description])
+              options.add_opt_list(opt[:name],opt[:values],opt[:description])
             elsif [:yes,:no].include?(opt[:default])
-              self.options.add_opt_boolean(opt[:name],opt[:description])
+              options.add_opt_boolean(opt[:name],opt[:description])
             else
-              self.options.add_opt_simple(opt[:name],opt[:description])
+              options.add_opt_simple(opt[:name],opt[:description])
             end
           end
 
-          self.options.parse_options!
+          options.parse_options!
           raise 'skip_folder shall be an Array, use @json:[...]' unless @option_skip_folders.is_a?(Array)
-          @tmp_folder=File.join(self.options.get_option(:temp_folder,:mandatory),"#{TMP_DIR_PREFIX}.#{SecureRandom.uuid}")
+          @tmp_folder=File.join(options.get_option(:temp_folder,:mandatory),"#{TMP_DIR_PREFIX}.#{SecureRandom.uuid}")
           FileUtils.mkdir_p(@tmp_folder)
           Log.log.debug("tmpdir: #{@tmp_folder}")
         end
@@ -97,7 +96,7 @@ module Aspera
         end
 
         def option_skip_types
-          return @skip_types.map{|i|i.to_s}.join(',')
+          return @skip_types.map(&:to_s).join(',')
         end
 
         def option_skip_format=(value)
@@ -105,7 +104,7 @@ module Aspera
         end
 
         def option_skip_format
-          return @preview_formats_to_generate.map{|i|i.to_s}.join(',')
+          return @preview_formats_to_generate.map(&:to_s).join(',')
         end
 
         # /files/id/files is normally cached in redis, but we can discard the cache
@@ -113,7 +112,7 @@ module Aspera
         def get_folder_entries(file_id,request_args=nil)
           headers={'Accept'=>'application/json'}
           headers.merge!({'X-Aspera-Cache-Control'=>'no-cache'}) if @option_folder_reset_cache.eql?(:header)
-          return @api_node.call({:operation=>'GET',:subpath=>"files/#{file_id}/files",:headers=>headers,:url_params=>request_args})[:data]
+          return @api_node.call({operation: 'GET',subpath: "files/#{file_id}/files",headers: headers,url_params: request_args})[:data]
           #return @api_node.read("files/#{file_id}/files",request_args)[:data]
         end
 
@@ -138,9 +137,9 @@ module Aspera
           end
           return if events.empty?
           events.each do |event|
-            if event['data']['direction'].eql?('receive') and
-            event['data']['status'].eql?('completed') and
-            event['data']['error_code'].eql?(0) and
+            if event['data']['direction'].eql?(Fasp::TransferSpec::DIRECTION_RECEIVE) &&
+            event['data']['status'].eql?('completed') &&
+            event['data']['error_code'].eql?(0) &&
             event['data'].dig('tags','aspera',PREV_GEN_TAG).nil?
               folder_id=event.dig('data','tags','aspera','node','file_id')
               folder_id||=event.dig('data','file_id')
@@ -149,13 +148,13 @@ module Aspera
                 scan_folder_files(folder_entry) unless folder_entry.nil?
               end
             end
-            if @periodic.trigger? or event.equal?(events.last)
-              Log.log.info("Processed event #{event['id']}")
-              # save checkpoint to avoid losing processing in case of error
-              if !iteration_persistency.nil?
-                iteration_persistency.data[0]=event['id'].to_s
-                iteration_persistency.save
-              end
+            # log/persist periodically or last one
+            next unless @periodic.trigger? || event.equal?(events.last)
+            Log.log.info("Processed event #{event['id']}")
+            # save checkpoint to avoid losing processing in case of error
+            if !iteration_persistency.nil?
+              iteration_persistency.data[0]=event['id'].to_s
+              iteration_persistency.save
             end
           end
         end
@@ -175,7 +174,7 @@ module Aspera
             # process only files
             if event.dig('data','type').eql?('file')
               file_entry=@api_node.read("files/#{event['data']['id']}")[:data] rescue nil
-              if !file_entry.nil? and
+              if !file_entry.nil? &&
               @option_skip_folders.select{|d|file_entry['path'].start_with?(d)}.empty?
                 file_entry['parent_file_id']=event['data']['parent_file_id']
                 if event['types'].include?('file.deleted')
@@ -186,30 +185,30 @@ module Aspera
                 end
               end
             end
-            if @periodic.trigger? or event.equal?(events.last)
-              Log.log.info("Processing event #{event['id']}")
-              # save checkpoint to avoid losing processing in case of error
-              if !iteration_persistency.nil?
-                iteration_persistency.data[0]=event['id'].to_s
-                iteration_persistency.save
-              end
+            # log/persist periodically or last one
+            next unless @periodic.trigger? || event.equal?(events.last)
+            Log.log.info("Processing event #{event['id']}")
+            # save checkpoint to avoid losing processing in case of error
+            if !iteration_persistency.nil?
+              iteration_persistency.data[0]=event['id'].to_s
+              iteration_persistency.save
             end
           end
         end
 
         def do_transfer(direction,folder_id,source_filename,destination='/')
-          raise "error" if destination.nil? and direction.eql?('receive')
+          raise 'error' if destination.nil? && direction.eql?(Fasp::TransferSpec::DIRECTION_RECEIVE)
           if @default_transfer_spec.nil?
             # make a dummy call to get some default transfer parameters
             res=@api_node.create('files/upload_setup',{'transfer_requests'=>[{'transfer_request'=>{'paths'=>[{}],'destination_root'=>'/'}}]})
             template_ts=res[:data]['transfer_specs'].first['transfer_spec']
             # get ports, anyway that should be 33001 for both. add remote_user ?
-            @default_transfer_spec=['ssh_port','fasp_port'].inject({}){|h,e|h[e]=template_ts[e];h}
-            if ! @default_transfer_spec['remote_user'].eql?(Aspera::Fasp::Default::ACCESS_KEY_TRANSFER_USER)
-              Log.log.warn("remote_user shall be xfer")
-              @default_transfer_spec['remote_user']=Aspera::Fasp::Default::ACCESS_KEY_TRANSFER_USER
+            @default_transfer_spec=['ssh_port','fasp_port'].each_with_object({}){|e,h|h[e]=template_ts[e];}
+            if !@default_transfer_spec['remote_user'].eql?(Aspera::Fasp::TransferSpec::ACCESS_KEY_TRANSFER_USER)
+              Log.log.warn('remote_user shall be xfer')
+              @default_transfer_spec['remote_user']=Aspera::Fasp::TransferSpec::ACCESS_KEY_TRANSFER_USER
             end
-            Aspera::Node::set_ak_basic_token(@default_transfer_spec,@access_key_self['id'],self.options.get_option(:password,:mandatory))
+            Aspera::Node.set_ak_basic_token(@default_transfer_spec,@access_key_self['id'],options.get_option(:password,:mandatory))
             # note: we use the same address for ascp than for node api instead of the one from upload_setup
             # TODO: configurable ? useful ?
             @default_transfer_spec['remote_host']=@transfer_server_address
@@ -225,33 +224,34 @@ module Aspera
           })
           # force destination
           # tspec['destination_root']=destination
-          self.transfer.option_transfer_spec_deep_merge({'destination_root'=>destination})
-          Main.result_transfer(self.transfer.start(tspec,{:src=>:node_gen4}))
+          transfer.option_transfer_spec_deep_merge({'destination_root'=>destination})
+          Main.result_transfer(transfer.start(tspec,{src: :node_gen4}))
         end
 
-        def get_infos_local(gen_infos,entry,local_entry_preview_dir)
+        def get_infos_local(gen_infos,entry)
           local_original_filepath=File.join(@local_storage_root,entry['path'])
           original_mtime=File.mtime(local_original_filepath)
           # out
-          local_entry_preview_dir.replace(File.join(@local_preview_folder, entry_preview_folder_name(entry)))
+          local_entry_preview_dir=File.join(@local_preview_folder, entry_preview_folder_name(entry))
           gen_infos.each do |gen_info|
             gen_info[:src]=local_original_filepath
             gen_info[:dst]=File.join(local_entry_preview_dir, gen_info[:base_dest])
             gen_info[:preview_exist]=File.exist?(gen_info[:dst])
             gen_info[:preview_newer_than_original] = (gen_info[:preview_exist] and (File.mtime(gen_info[:dst])>original_mtime))
           end
+          return local_entry_preview_dir
         end
 
-        def get_infos_remote(gen_infos,entry,local_entry_preview_dir)
+        def get_infos_remote(gen_infos,entry)
           #Log.log.debug(">>>> get_infos_remote #{entry}".red)
           # store source directly here
           local_original_filepath=File.join(@tmp_folder,entry['name'])
           #original_mtime=DateTime.parse(entry['modified_time'])
           # out: where previews are generated
-          local_entry_preview_dir.replace(File.join(@tmp_folder,entry_preview_folder_name(entry)))
+          local_entry_preview_dir=File.join(@tmp_folder,entry_preview_folder_name(entry))
           file_info=@api_node.read("files/#{entry['id']}")[:data]
           #TODO: this does not work because previews is hidden in api (gen4)
-          #this_preview_folder_entries=get_folder_entries(@previews_folder_entry['id'],{:name=>@entry_preview_folder_name})
+          #this_preview_folder_entries=get_folder_entries(@previews_folder_entry['id'],{name: @entry_preview_folder_name})
           # TODO: use gen3 api to list files and get date
           gen_infos.each do |gen_info|
             gen_info[:src]=local_original_filepath
@@ -261,6 +261,7 @@ module Aspera
             # TODO: get change time and compare, useful ?
             gen_info[:preview_newer_than_original] = gen_info[:preview_exist]
           end
+          return local_entry_preview_dir
         end
 
         # defined by node api
@@ -270,29 +271,23 @@ module Aspera
 
         def preview_filename(preview_format,filename=nil)
           filename||=PREVIEW_BASENAME
-          return "#{filename}.#{preview_format.to_s}"
+          return "#{filename}.#{preview_format}"
         end
 
         # generate preview files for one folder entry (file) if necessary
         # entry must contain "parent_file_id" if remote.
         def generate_preview(entry)
-          #Log.log.debug(">>>> #{entry}".red)
-          # folder where previews will be generated for this particular entry
-          local_entry_preview_dir=String.new
           # prepare generic information
           gen_infos=@preview_formats_to_generate.map do |preview_format|
             {
-              :preview_format => preview_format,
-              :base_dest      => preview_filename(preview_format)
+              preview_format:  preview_format,
+              base_dest:       preview_filename(preview_format)
             }
           end
           # lets gather some infos on possibly existing previews
           # it depends if files access locally or remotely
-          if @access_remote
-            get_infos_remote(gen_infos,entry,local_entry_preview_dir)
-          else # direct local file system access
-            get_infos_local(gen_infos,entry,local_entry_preview_dir)
-          end
+          # folder where previews will be generated for this particular entry
+          local_entry_preview_dir=@access_remote ? get_infos_remote(gen_infos,entry) : get_infos_local(gen_infos,entry)
           # here we have the status on preview files
           # let's find if they need generation
           gen_infos.select! do |gen_info|
@@ -324,7 +319,7 @@ module Aspera
           if @access_remote
             raise 'missing parent_file_id in entry' if entry['parent_file_id'].nil?
             #  download original file to temp folder
-            do_transfer('receive',entry['parent_file_id'],entry['name'],@tmp_folder)
+            do_transfer(Fasp::TransferSpec::DIRECTION_RECEIVE,entry['parent_file_id'],entry['name'],@tmp_folder)
           end
           Log.log.info("source: #{entry['id']}: #{entry['path']})")
           gen_infos.each do |gen_info|
@@ -332,7 +327,7 @@ module Aspera
           end
           if @access_remote
             # upload
-            do_transfer('send',@previews_folder_entry['id'],local_entry_preview_dir)
+            do_transfer(Fasp::TransferSpec::DIRECTION_SEND,@previews_folder_entry['id'],local_entry_preview_dir)
             # cleanup after upload
             FileUtils.rm_rf(local_entry_preview_dir)
             File.delete(File.join(@tmp_folder,entry['name']))
@@ -341,8 +336,8 @@ module Aspera
           if @option_folder_reset_cache.eql?(:read)
             @api_node.read("files/#{entry['id']}")
           end
-        rescue => e
-          Log.log.error("#{e.message}")
+        rescue StandardError => e
+          Log.log.error("Ignore: #{e.message}")
           Log.log.debug(e.backtrace.join("\n").red)
         end # generate_preview
 
@@ -351,7 +346,7 @@ module Aspera
         def scan_folder_files(top_entry,scan_start=nil)
           if !scan_start.nil?
             # canonical path: start with / and ends with /
-            scan_start='/'+scan_start.split('/').select{|i|!i.empty?}.join('/')
+            scan_start='/'+scan_start.split('/').reject(&:empty?).join('/')
             scan_start="#{scan_start}/" #unless scan_start.end_with?('/')
           end
           filter_block=Aspera::Node.file_matcher(options.get_option(:value,:optional))
@@ -364,7 +359,7 @@ module Aspera
             entry_path_with_slash=entry['path']
             Log.log.info("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 !scan_start.nil? and !scan_start.start_with?(entry_path_with_slash) and !entry_path_with_slash.start_with?(scan_start)
+            if !scan_start.nil? && !scan_start.start_with?(entry_path_with_slash) && !entry_path_with_slash.start_with?(scan_start)
               Log.log.debug("#{entry['path']} folder (skip start)".bg_red)
               next
             end
@@ -399,7 +394,7 @@ module Aspera
               else
                 Log.log.warn("unknown entry type: #{entry['type']}")
               end
-            rescue => e
+            rescue StandardError => e
               Log.log.warn("An error occured: #{e}, ignoring")
             end
           end
@@ -408,7 +403,7 @@ module Aspera
         ACTIONS=[:scan,:events,:trevents,:check,:test]
 
         def execute_action
-          command=self.options.get_next_command(ACTIONS)
+          command=options.get_next_command(ACTIONS)
           unless [:check,:test].include?(command)
             # this will use node api
             @api_node=basic_auth_api
@@ -426,10 +421,10 @@ module Aspera
             @option_skip_folders.push('/'+@option_previews_folder)
             if @access_remote
               # note the filter "name", it's why we take the first one
-              @previews_folder_entry=get_folder_entries(@access_key_self['root_file_id'],{:name=>@option_previews_folder}).first
+              @previews_folder_entry=get_folder_entries(@access_key_self['root_file_id'],{name: @option_previews_folder}).first
               raise CliError,"Folder #{@option_previews_folder} does not exist on node. Please create it in the storage root, or specify an alternate name." if @previews_folder_entry.nil?
             else
-              raise "only local storage allowed in this mode" unless @access_key_self['storage']['type'].eql?('local')
+              raise 'only local storage allowed in this mode' unless @access_key_self['storage']['type'].eql?('local')
               @local_storage_root=@access_key_self['storage']['path']
               #TODO: option to override @local_storage_root='xxx'
               @local_storage_root=@local_storage_root[LOCAL_STORAGE_PCVL.length..-1] if @local_storage_root.start_with?(LOCAL_STORAGE_PCVL)
@@ -449,13 +444,14 @@ module Aspera
               end
             end
           end
-          Aspera::Preview::FileTypes.instance.use_mimemagic = self.options.get_option(:mimemagic,:mandatory)
+          Aspera::Preview::FileTypes.instance.use_mimemagic = options.get_option(:mimemagic,:mandatory)
           case command
           when :scan
-            scan_path=self.options.get_option(:scan_path,:optional)
-            scan_id=self.options.get_option(:scan_id,:optional)
+            scan_path=options.get_option(:scan_path,:optional)
+            scan_id=options.get_option(:scan_id,:optional)
             # by default start at root
-            folder_info=if scan_id.nil?
+            folder_info=
+            if scan_id.nil?
               { 'id'   => @access_key_self['root_file_id'],
                 'name' => '/',
                 'type' => 'folder',
@@ -467,11 +463,11 @@ module Aspera
             return Main.result_status('scan finished')
           when :events,:trevents
             iteration_persistency=nil
-            if self.options.get_option(:once_only,:mandatory)
+            if options.get_option(:once_only,:mandatory)
               iteration_persistency=PersistencyActionOnce.new(
               manager: @agents[:persistency],
               data:    [],
-              id:      IdGenerator.from_list(['preview_iteration',command.to_s,self.options.get_option(:url,:mandatory),self.options.get_option(:username,:mandatory)]))
+              id:      IdGenerator.from_list(['preview_iteration',command.to_s,options.get_option(:url,:mandatory),options.get_option(:username,:mandatory)]))
             end
             # call processing method specified by command line command
             send("process_#{command}",iteration_persistency)
@@ -480,16 +476,16 @@ module Aspera
             Aspera::Preview::Utils.check_tools(@skip_types)
             return Main.result_status('tools validated')
           when :test
-            format = self.options.get_next_argument('format',Aspera::Preview::Generator::PREVIEW_FORMATS)
-            source = self.options.get_next_argument('source file')
-            dest=preview_filename(format,self.options.get_option(:case,:optional))
+            format = options.get_next_argument('format',Aspera::Preview::Generator::PREVIEW_FORMATS)
+            source = options.get_next_argument('source file')
+            dest=preview_filename(format,options.get_option(:case,:optional))
             g=Aspera::Preview::Generator.new(@gen_options,source,dest,@tmp_folder,nil)
             raise "cannot find file type for #{source}" if g.conversion_type.nil?
             raise "out format #{format} not supported" unless g.supported?
             g.generate
             return Main.result_status("generated: #{dest}")
           else
-            raise "error"
+            raise 'error'
           end
         ensure
           FileUtils.rm_rf(@tmp_folder)