aspera-cli 4.20.0 → 4.21.0

data/lib/aspera/ascp/installation.rb

@@ -3,11 +3,16 @@
 # cspell:ignore protobuf ckpt
 require 'aspera/environment'
 require 'aspera/data_repository'
-require 'aspera/ascp/products'
 require 'aspera/log'
 require 'aspera/rest'
 require 'aspera/assert'
 require 'aspera/web_server_simple'
+require 'aspera/cli/info'
+require 'aspera/cli/version'
+require 'aspera/products/alpha'
+require 'aspera/products/connect'
+require 'aspera/products/trsdk'
+require 'aspera/products/other'
 require 'English'
 require 'singleton'
 require 'xmlsimple'
@@ -20,7 +25,7 @@ module Aspera
     # Singleton that tells where to find ascp and other local resources (keys..) , using the "path(:name)" method.
     # It is used by object : AgentDirect to find necessary resources
     # By default it takes the first Aspera product found
-    # but the user can specify ascp location by calling:
+    # The user can specify ascp location by calling:
     # Installation.instance.use_ascp_from_product(product_name)
     # or
     # Installation.instance.ascp_path=""
@@ -46,12 +51,16 @@ module Aspera
       TRANSFER_SDK_LOCATION_URL = 'https://ibm.biz/sdk_location'
       FILE_SCHEME_PREFIX = 'file:///'
       SDK_ARCHIVE_FOLDERS = ['/bin/', '/aspera/'].freeze
+      # filename for ascp with optional extension (Windows)
       private_constant :EXT_RUBY_PROTOBUF, :RB_SDK_SUBFOLDER, :DEFAULT_ASPERA_CONF, :FILES, :TRANSFER_SDK_LOCATION_URL, :FILE_SCHEME_PREFIX
       # options for SSH client private key
       CLIENT_SSH_KEY_OPTIONS = %i{dsa_rsa rsa per_client}.freeze
 
       # set ascp executable path
       def ascp_path=(v)
+        Aspera.assert_type(v, String)
+        Aspera.assert(!v.empty?) {'ascp path cannot be empty: check your config file'}
+        Aspera.assert(File.exist?(v)) {"No such file: [#{v}]"}
         @path_to_ascp = v
       end
 
@@ -59,31 +68,19 @@ module Aspera
         path(:ascp)
       end
 
-      # location of SDK files
+      # Compatibility
       def sdk_folder=(v)
-        Log.log.debug{"sdk_folder=#{v}"}
-        @sdk_dir = v
-        sdk_folder
-      end
-
-      # backward compatibility in sample program
-      alias_method :folder=, :sdk_folder=
-
-      # @return the path to folder where SDK is installed
-      def sdk_folder
-        raise 'SDK path was ot initialized' if @sdk_dir.nil?
-        FileUtils.mkdir_p(@sdk_dir)
-        @sdk_dir
+        Products::Trsdk.sdk_directory = v
       end
 
       # find ascp in named product (use value : FIRST_FOUND='FIRST' to just use first one)
-      # or select one from Products.installed_products()
+      # or select one from installed_products()
       def use_ascp_from_product(product_name)
         if product_name.eql?(FIRST_FOUND)
-          pl = Products.installed_products.first
-          raise "ascp found: no Aspera transfer module or SDK found.\nRefer to the manual or install SDK with command:\nascli conf ascp install" if pl.nil?
+          pl = installed_products.first
+          raise "no Aspera transfer module or SDK found.\nRefer to the manual or install SDK with command:\nascli conf ascp install" if pl.nil?
         else
-          pl = Products.installed_products.find{|i|i[:name].eql?(product_name)}
+          pl = installed_products.find{|i|i[:name].eql?(product_name)}
           raise "no such product installed: #{product_name}" if pl.nil?
         end
         self.ascp_path = pl[:ascp_path]
@@ -103,7 +100,7 @@ module Aspera
       end
 
       def check_or_create_sdk_file(filename, force: false, &block)
-        return Environment.write_file_restricted(File.join(sdk_folder, filename), force: force, mode: 0o644, &block)
+        return Environment.write_file_restricted(File.join(Products::Trsdk.sdk_directory, filename), force: force, mode: 0o644, &block)
       end
 
       # get path of one resource file of currently activated product
@@ -118,7 +115,7 @@ module Aspera
           file = @path_to_ascp.gsub('ascp', k.to_s)
         when :transferd
           file_is_optional = true
-          file = transferd_filepath
+          file = Products::Trsdk.transferd_path
         when :ssh_private_dsa, :ssh_private_rsa
           # assume last 3 letters are type
           type = k.to_s[-3..-1].to_sym
@@ -128,8 +125,8 @@ module Aspera
         when :aspera_conf
           file = check_or_create_sdk_file('aspera.conf') {DEFAULT_ASPERA_CONF}
         when :fallback_certificate, :fallback_private_key
-          file_key = File.join(sdk_folder, 'aspera_fallback_cert_private_key.pem')
-          file_cert = File.join(sdk_folder, 'aspera_fallback_cert.pem')
+          file_key = File.join(Products::Trsdk.sdk_directory, 'aspera_fallback_cert_private_key.pem')
+          file_cert = File.join(Products::Trsdk.sdk_directory, 'aspera_fallback_cert.pem')
           if !File.exist?(file_key) || !File.exist?(file_cert)
             require 'openssl'
             # create new self signed certificate for http fallback
@@ -143,7 +140,7 @@ module Aspera
         else Aspera.error_unexpected_value(k)
         end
         return nil if file_is_optional && !File.exist?(file)
-        Aspera.assert(File.exist?(file)){"no such file: #{file}"}
+        Aspera.assert(File.exist?(file)){"no such file for #{k}: [#{file}]"}
         return file
       end
 
@@ -239,7 +236,14 @@ module Aspera
       # Loads YAML from cloud with locations of SDK archives for all platforms
       # @return location structure
       def sdk_locations
-        yaml_text = Aspera::Rest.new(base_url: TRANSFER_SDK_LOCATION_URL, redirect_max: 3).call(operation: 'GET')[:data]
+        yaml_text = Aspera::Rest.new(
+          base_url: TRANSFER_SDK_LOCATION_URL,
+          redirect_max: 3).call(
+            operation: 'GET',
+            headers: {
+              'Referer' => "http://version.#{Cli::VERSION}"
+            }
+          )[:data]
         YAML.load(yaml_text)
       end
 
@@ -255,6 +259,7 @@ module Aspera
         return info.first['url']
       end
 
+      # @param &block called with entry information
       def extract_archive_files(sdk_archive_path)
         raise 'missing block' unless block_given?
         case sdk_archive_path
@@ -265,7 +270,7 @@ module Aspera
           Zip::File.open(sdk_archive_path) do |zip_file|
             zip_file.each do |entry|
               next if entry.name.end_with?('/')
-              yield(entry.name, entry.get_input_stream)
+              yield(entry.name, entry.get_input_stream, nil)
             end
           end
         # Other Unixes use tar.gz
@@ -276,7 +281,7 @@ module Aspera
             Gem::Package::TarReader.new(gzip) do |tar|
               tar.each do |entry|
                 next if entry.directory?
-                yield(entry.full_name, entry)
+                yield(entry.full_name, entry, entry.symlink? ? entry.header.linkname : nil)
               end
             end
           end
@@ -287,11 +292,15 @@ module Aspera
 
       # download aspera SDK or use local file
       # extracts ascp binary for current system architecture
-      # @param url [String] URL to SDK archive, or SpecialValues::DEF
+      # @param url      [String] URL to SDK archive, or SpecialValues::DEF
+      # @param folder   [String] destination
+      # @param backup   [Bool]
+      # @param with_exe [Bool]
+      # @param &block   [Proc] a lambda that receives a file path from archive and tells detination sub folder, or nil to not extract
       # @return ascp version (from execution)
       def install_sdk(url: nil, folder: nil, backup: true, with_exe: true, &block)
         url = sdk_url_for_platform if url.nil? || url.eql?('DEF')
-        folder = sdk_folder if folder.nil?
+        folder = Products::Trsdk.sdk_directory if folder.nil?
         subfolder_lambda = block
         if subfolder_lambda.nil?
           subfolder_lambda = ->(name) do
@@ -318,13 +327,16 @@ module Aspera
           File.rename(folder, "#{folder}.#{Time.now.strftime('%Y%m%d%H%M%S')}")
           # TODO: delete old archives ?
         end
-        extract_archive_files(sdk_archive_path) do |entry_name, entry_stream|
+        extract_archive_files(sdk_archive_path) do |entry_name, entry_stream, link_target|
           subfolder = subfolder_lambda.call(entry_name)
           next if subfolder.nil?
           dest_folder = File.join(folder, subfolder)
           FileUtils.mkdir_p(dest_folder)
-          File.open(File.join(dest_folder, File.basename(entry_name)), 'wb') do |output_stream|
-            IO.copy_stream(entry_stream, output_stream)
+          new_file = File.join(dest_folder, File.basename(entry_name))
+          if link_target.nil?
+            File.open(new_file, 'wb') { |output_stream|IO.copy_stream(entry_stream, output_stream)}
+          else
+            File.symlink(link_target, new_file)
           end
         end
         File.unlink(sdk_archive_path) rescue nil if delete_archive # Windows may give error
@@ -332,7 +344,7 @@ module Aspera
         # ensure license file are generated so that ascp invocation for version works
         path(:aspera_license)
         path(:aspera_conf)
-        sdk_ascp_file = Products.ascp_filename
+        sdk_ascp_file = Environment.exe_file('ascp')
         sdk_ascp_path = File.join(folder, sdk_ascp_file)
         raise "No #{sdk_ascp_file} found in SDK archive" unless File.exist?(sdk_ascp_path)
         EXE_FILES.each do |exe_sym|
@@ -340,13 +352,13 @@ module Aspera
           Environment.restrict_file_access(exe_path, mode: 0o755) if File.exist?(exe_path)
         end
         sdk_ascp_version = get_ascp_version(sdk_ascp_path)
-        sdk_daemon_path = transferd_filepath
+        sdk_daemon_path = Products::Trsdk.transferd_path
         Log.log.warn{"No #{sdk_daemon_path} in SDK archive"} unless File.exist?(sdk_daemon_path)
         Environment.restrict_file_access(sdk_daemon_path, mode: 0o755) if File.exist?(sdk_daemon_path)
         transferd_version = get_exe_version(sdk_daemon_path, 'version')
         sdk_name = 'IBM Aspera Transfer SDK'
         sdk_version = transferd_version || sdk_ascp_version
-        File.write(File.join(folder, Products::INFO_META_FILE), "<product><name>#{sdk_name}</name><version>#{sdk_version}</version></product>")
+        File.write(File.join(folder, Products::Other::INFO_META_FILE), "<product><name>#{sdk_name}</name><version>#{sdk_version}</version></product>")
         return sdk_name, sdk_version
       end
 
@@ -358,10 +370,29 @@ module Aspera
       def initialize
         @path_to_ascp = nil
         @sdk_dir = nil
+        @found_products = nil
       end
 
-      def transferd_filepath
-        return File.join(sdk_folder, 'asperatransferd' + Environment.exe_extension) # cspell:disable-line
+      public
+
+      # @return the list of installed products in format of product_locations_on_current_os
+      def installed_products
+        if @found_products.nil?
+          # :expected  M app name is taken from the manifest if present, else defaults to this value
+          # :app_root  M main folder for the application
+          # :log_root  O location of log files (Linux uses syslog)
+          # :run_root  O only for Connect Client, location of http port file
+          # :sub_bin   O subfolder with executables, default : bin
+          scan_locations = Products::Trsdk.locations.concat(
+            Products::Alpha.locations,
+            Products::Connect.locations,
+            Products::Other::LOCATION_ON_THIS_OS
+          )
+          # .each {|item| item.deep_do {|h, _k, _v, _m|h.freeze}}.freeze
+          # search installed products: with ascp
+          @found_products = Products::Other.find(scan_locations)
+        end
+        return @found_products
       end
     end
   end

data/lib/aspera/ascp/management.rb

@@ -198,18 +198,39 @@ module Aspera
       BOOLEAN_FIELDS = %w[Encryption Remote RateLock MinRateLock PolicyLock FilesEncrypt FilesDecrypt VLinkLocalEnabled VLinkRemoteEnabled
                           MoveRange Keepalive TestLogin UseProxy Precalc RTTAutocorrect].freeze
       BOOLEAN_TRUE = 'Yes'
+
+      private_constant :OPERATIONS, :PARAMETERS, :MGT_HEADER, :MGT_FRAME_SEPARATOR, :INTEGER_FIELDS, :BOOLEAN_FIELDS, :BOOLEAN_TRUE
       # cspell: enable
 
       class << self
         # translates mgt port event into (enhanced) typed event
         def enhanced_event_format(event)
           return event.keys.each_with_object({}) do |e, h|
-            new_name = e.capital_to_snake.gsub(/(usec)$/, '_\1').downcase
-            value = event[e]
-            value = value.to_i if INTEGER_FIELDS.include?(e)
-            value = value.eql?(BOOLEAN_TRUE) if BOOLEAN_FIELDS.include?(e)
-            h[new_name] = value
-          end
+                   new_name =
+                     case e
+                     when 'Elapsedusec' then 'elapsed_usec'
+                     when 'Bytescont' then 'bytes_cont'
+                     else e.capital_to_snake
+                     end
+                   h[new_name] =
+                     if INTEGER_FIELDS.include?(e) then event[e].to_i
+                     elsif BOOLEAN_FIELDS.include?(e) then event[e].eql?(BOOLEAN_TRUE)
+                     else
+                       event[e]
+                     end
+                 end
+        end
+
+        # build command to send on management port
+        # @param data [Hash] {'type'=>'START','source'=>_path_,'destination'=>_path_}
+        def command_to_stream(data)
+          # TODO: translate enhanced to capitalized ?
+          data
+            .keys
+            .map{|k|"#{k.capitalize}: #{data[k]}"}
+            .unshift(MGT_HEADER)
+            .push('', '')
+            .join("\n")
         end
       end
 

data/lib/aspera/cli/formatter.rb

@@ -101,9 +101,10 @@ module Aspera
       DISPLAY_FORMATS = %i[text nagios ruby json jsonpp yaml table csv image].freeze
       # user output levels
       DISPLAY_LEVELS = %i[info data error].freeze
-      FIELD_VALUE_HEADINGS = %i[key value].freeze
+      # column names for single object display in table
+      SINGLE_OBJECT_COLUMN_NAMES = %i[field value].freeze
 
-      private_constant :DISPLAY_FORMATS, :DISPLAY_LEVELS, :CSV_RECORD_SEPARATOR, :CSV_FIELD_SEPARATOR, :FIELD_VALUE_HEADINGS
+      private_constant :FIELDS_LESS, :CSV_RECORD_SEPARATOR, :CSV_FIELD_SEPARATOR, :DISPLAY_FORMATS, :DISPLAY_LEVELS, :SINGLE_OBJECT_COLUMN_NAMES
       # prefix to display error messages in user messages (terminal)
       ERROR_FLASH = 'ERROR:'.bg_red.gray.blink.freeze
       WARNING_FLASH = 'WARNING:'.bg_brown.black.blink.freeze
@@ -172,12 +173,37 @@ module Aspera
         @spinner = nil
       end
 
-      # options are: format, output, display, fields, select, table_style, flat_hash, transpose_single
+      def declare_options(options)
+        default_table_style = if Environment.instance.terminal_supports_unicode?
+          {border: :unicode_round}
+        else
+          {}
+        end
+        options.declare(:format, 'Output format', values: DISPLAY_FORMATS, handler: {o: self, m: :option_handler}, default: :table)
+        options.declare(:output, 'Destination for results', types: String, handler: {o: self, m: :option_handler})
+        options.declare(:display, 'Output only some information', values: DISPLAY_LEVELS, handler: {o: self, m: :option_handler}, default: :info)
+        options.declare(
+          :fields, "Comma separated list of: fields, or #{SpecialValues::ALL}, or #{SpecialValues::DEF}", handler: {o: self, m: :option_handler},
+          types: [String, Array, Regexp, Proc],
+          default: SpecialValues::DEF)
+        options.declare(:select, 'Select only some items in lists: column, value', types: [Hash, Proc], handler: {o: self, m: :option_handler})
+        options.declare(:table_style, 'Table display style', types: [Hash], handler: {o: self, m: :option_handler}, default: default_table_style)
+        options.declare(:flat_hash, '(Table) Display deep values as additional keys', values: :bool, handler: {o: self, m: :option_handler}, default: true)
+        options.declare(
+          :multi_single, '(Table) Control how object list is displayed as single table, or multiple objects', values: %i[no yes single],
+          handler: {o: self, m: :option_handler}, default: :no)
+        options.declare(:show_secrets, 'Show secrets on command output', values: :bool, handler: {o: self, m: :option_handler}, default: false)
+        options.declare(:image, 'Options for image display', types: Hash, handler: {o: self, m: :option_handler}, default: {})
+      end
+
+      # method accessed by option manager
+      # options are: format, output, display, fields, select, table_style, flat_hash, multi_single
       def option_handler(option_symbol, operation, value=nil)
         Aspera.assert_values(operation, %i[set get])
         case operation
         when :set
           @options[option_symbol] = value
+          # special handling of some options
           case option_symbol
           when :output
             $stdout = if value.eql?('-')
@@ -186,7 +212,9 @@ module Aspera
               File.open(value, 'w')
             end
           when :image
+            # get list if key arguments of method
             allowed_options = Preview::Terminal.method(:build).parameters.select{|i|i[0].eql?(:key)}.map{|i|i[1]}
+            # check that only supported options are given
             unknown_options = value.keys.map(&:to_sym) - allowed_options
             raise "Invalid parameter(s) for option image: #{unknown_options.join(', ')}, use #{allowed_options.join(', ')}" unless unknown_options.empty?
           end
@@ -196,28 +224,6 @@ module Aspera
         nil
       end
 
-      def declare_options(options)
-        default_table_style = if Environment.instance.terminal_supports_unicode?
-          {border: :unicode_round}
-        else
-          {}
-        end
-        options.declare(:format, 'Output format', values: DISPLAY_FORMATS, handler: {o: self, m: :option_handler}, default: :table)
-        options.declare(:output, 'Destination for results', types: String, handler: {o: self, m: :option_handler})
-        options.declare(:display, 'Output only some information', values: DISPLAY_LEVELS, handler: {o: self, m: :option_handler}, default: :info)
-        options.declare(
-          :fields, "Comma separated list of: fields, or #{SpecialValues::ALL}, or #{SpecialValues::DEF}", handler: {o: self, m: :option_handler},
-          types: [String, Array, Regexp, Proc],
-          default: SpecialValues::DEF)
-        options.declare(:select, 'Select only some items in lists: column, value', types: [Hash, Proc], handler: {o: self, m: :option_handler})
-        options.declare(:table_style, 'Table display style', types: [Hash], handler: {o: self, m: :option_handler}, default: default_table_style)
-        options.declare(:flat_hash, '(Table) Display deep values as additional keys', values: :bool, handler: {o: self, m: :option_handler}, default: true)
-        options.declare(:transpose_single, '(Table) Single object fields output vertically', values: :bool, handler: {o: self, m: :option_handler}, default: true)
-        options.declare(:multi_table, '(Table) Each element of a table are displayed as a table', values: :bool, handler: {o: self, m: :option_handler}, default: false)
-        options.declare(:show_secrets, 'Show secrets on command output', values: :bool, handler: {o: self, m: :option_handler}, default: false)
-        options.declare(:image, 'Options for image display', types: Hash, handler: {o: self, m: :option_handler}, default: {})
-      end
-
       # main output method
       # data: for requested data, not displayed if level==error
       # info: additional info, displayed if level==info
@@ -244,6 +250,118 @@ module Aspera
         display_status(count_msg)
       end
 
+      # this method displays the results, especially the table format
+      # @param type [Symbol] type of data
+      # @param data [Object] data to display
+      # @param total [Integer] total number of items
+      # @param fields [Array<String>] list of fields to display
+      # @param name [String] name of the column to display
+      def display_results(type:, data: nil, total: nil, fields: nil, name: nil)
+        Log.log.debug{"display_results: #{type} class=#{data.class}"}
+        Log.log.trace1{"display_results:data=#{data}"}
+        Aspera.assert_type(type, Symbol){'result must have type'}
+        Aspera.assert(!data.nil? || %i[empty nothing].include?(type)){'result must have data'}
+        display_item_count(data.length, total) unless total.nil?
+        SecretHider.deep_remove_secret(data) unless @options[:show_secrets] || @options[:display].eql?(:data)
+        case @options[:format]
+        when :text
+          display_message(:data, data.to_s)
+        when :nagios
+          Nagios.process(data)
+        when :ruby
+          display_message(:data, PP.pp(filter_list_on_fields(data), +''))
+        when :json
+          display_message(:data, JSON.generate(filter_list_on_fields(data)))
+        when :jsonpp
+          display_message(:data, JSON.pretty_generate(filter_list_on_fields(data)))
+        when :yaml
+          display_message(:data, YAML.dump(filter_list_on_fields(data)))
+        when :image
+          # assume it is an url
+          url = data
+          case type
+          when :single_object, :object_list
+            url = [url] if type.eql?(:single_object)
+            raise 'image display requires a single result' unless url.length == 1
+            fields = compute_fields(url, fields)
+            raise 'select a field to display' unless fields.length == 1
+            url = url.first
+            raise 'no such field' unless url.key?(fields.first)
+            url = url[fields.first]
+          end
+          raise "not url: #{url.class} #{url}" unless url.is_a?(String)
+          display_message(:data, status_image(url))
+        when :table, :csv
+          case type
+          when :config_over
+            display_table(Flattener.new(self).config_over(data), CONF_OVERVIEW_KEYS)
+          when :object_list, :single_object
+            obj_list = data
+            if type.eql?(:single_object)
+              obj_list = [obj_list]
+              @options[:multi_single] = :yes
+            end
+            Aspera.assert_type(obj_list, Array)
+            Aspera.assert(obj_list.all?(Hash)){"expecting Array of Hash: #{obj_list.inspect}"}
+            # :object_list is an array of hash tables, where key=colum name
+            obj_list = obj_list.map{|obj|Flattener.new(self).flatten(obj)} if @options[:flat_hash]
+            display_table(obj_list, compute_fields(obj_list, fields))
+          when :value_list
+            # :value_list is a simple array of values, name of column provided in the :name
+            display_table(data.map { |i| { name => i } }, [name])
+          when :empty # no table
+            display_message(:info, special_format('empty'))
+            return
+          when :nothing # no result expected
+            Log.log.debug('no result expected')
+          when :status # no table
+            # :status displays a simple message
+            display_message(:info, data)
+          when :text # no table
+            # :status displays a simple message
+            display_message(:data, data)
+          when :other_struct # no table
+            # :other_struct is any other type of structure
+            display_message(:data, PP.pp(data, +''))
+          else
+            raise "unknown data type: #{type}"
+          end
+        else
+          raise "not expected: #{@options[:format]}"
+        end
+      end
+
+      # @return text suitable to display an image from url
+      # # can be used in
+      def status_image(blob)
+        begin
+          raise URI::InvalidURIError, 'not uri' if !(blob =~ /\A#{URI::RFC2396_PARSER.make_regexp}\z/)
+          # it's a url
+          url = blob
+          unless Environment.instance.url_method.eql?(:text)
+            Environment.instance.open_uri(url)
+            return ''
+          end
+          # remote_image = Rest.new(base_url: url).read('')
+          # mime = remote_image[:http]['content-type']
+          # blob = remote_image[:http].body
+          # Log.log.warn("Image ? #{remote_image[:http]['content-type']}") unless mime.include?('image/')
+          blob = UriReader.read(url)
+        rescue URI::InvalidURIError
+          nil
+        end
+        # try base64
+        begin
+          blob = Base64.strict_decode64(blob)
+        rescue
+          nil
+        end
+        return Preview::Terminal.build(blob, **@options[:image].symbolize_keys)
+      end
+      #==========================================================================================
+
+      private
+
       def all_fields(data)
         data.each_with_object({}){|v, m|v.each_key{|c|m[c] = true}}.keys
       end
@@ -314,9 +432,9 @@ module Aspera
         end
       end
 
-      # this method displays a table
-      # object_array: array of hash
-      # fields: list of column names
+      # displays a list of objects
+      # @param object_array  [Array] array of hash
+      # @param fields        [Array] list of column names
       def display_table(object_array, fields)
         Aspera.assert(!fields.nil?){'missing fields parameter'}
         filter_columns_on_select(object_array)
@@ -330,13 +448,6 @@ module Aspera
           display_message(:data, object_array.first[fields.first])
           return
         end
-        single_transposed = @options[:transpose_single] && object_array.length == 1
-        # Special case if only one row (it could be object_list or single_object)
-        if single_transposed
-          single = object_array.first
-          object_array = fields.map { |i| FIELD_VALUE_HEADINGS.zip([i, single[i]]).to_h }
-          fields = FIELD_VALUE_HEADINGS
-        end
         Log.log.debug{Log.dump(:object_array, object_array)}
         # convert data to string, and keep only display fields
         final_table_rows = object_array.map { |r| fields.map { |c| r[c].to_s } }
@@ -345,11 +456,12 @@ module Aspera
         # here : fields : list of column names
         case @options[:format]
         when :table
-          if @options[:multi_table] && !single_transposed
+          if @options[:multi_single].eql?(:yes) ||
+              (@options[:multi_single].eql?(:single) && final_table_rows.length.eql?(1))
             final_table_rows.each do |row|
               Log.log.debug{Log.dump(:row, row)}
               display_message(:data, Terminal::Table.new(
-                headings:  FIELD_VALUE_HEADINGS,
+                headings:  SINGLE_OBJECT_COLUMN_NAMES,
                 rows:      fields.zip(row),
                 style:     @options[:table_style]&.symbolize_keys))
             end
@@ -366,110 +478,6 @@ module Aspera
           raise "not expected: #{@options[:format]}"
         end
       end
-
-      # @return text suitable to display an image from url
-      def status_image(blob)
-        begin
-          raise URI::InvalidURIError, 'not uri' if !(blob =~ /\A#{URI::RFC2396_PARSER.make_regexp}\z/)
-          # it's a url
-          url = blob
-          unless Environment.instance.url_method.eql?(:text)
-            Environment.instance.open_uri(url)
-            return ''
-          end
-          # remote_image = Rest.new(base_url: url).read('')
-          # mime = remote_image[:http]['content-type']
-          # blob = remote_image[:http].body
-          # Log.log.warn("Image ? #{remote_image[:http]['content-type']}") unless mime.include?('image/')
-          blob = UriReader.read(url)
-        rescue URI::InvalidURIError
-          nil
-        end
-        # try base64
-        begin
-          blob = Base64.strict_decode64(blob)
-        rescue
-          nil
-        end
-        return Preview::Terminal.build(blob, **@options[:image].symbolize_keys)
-      end
-
-      # this method displays the results, especially the table format
-      # @param type [Symbol] type of data
-      # @param data [Object] data to display
-      # @param total [Integer] total number of items
-      # @param fields [Array<String>] list of fields to display
-      # @param name [String] name of the column to display
-      def display_results(type:, data: nil, total: nil, fields: nil, name: nil)
-        Log.log.debug{"display_results: #{type} class=#{data.class} data=#{data}"}
-        Aspera.assert_type(type, Symbol){'result must have type'}
-        Aspera.assert(!data.nil? || %i[empty nothing].include?(type)){'result must have data'}
-        display_item_count(data.length, total) unless total.nil?
-        SecretHider.deep_remove_secret(data) unless @options[:show_secrets] || @options[:display].eql?(:data)
-        case @options[:format]
-        when :text
-          display_message(:data, data.to_s)
-        when :nagios
-          Nagios.process(data)
-        when :ruby
-          display_message(:data, PP.pp(filter_list_on_fields(data), +''))
-        when :json
-          display_message(:data, JSON.generate(filter_list_on_fields(data)))
-        when :jsonpp
-          display_message(:data, JSON.pretty_generate(filter_list_on_fields(data)))
-        when :yaml
-          display_message(:data, YAML.dump(filter_list_on_fields(data)))
-        when :image
-          # assume it is an url
-          url = data
-          case type
-          when :single_object, :object_list
-            url = [url] if type.eql?(:single_object)
-            raise 'image display requires a single result' unless url.length == 1
-            fields = compute_fields(url, fields)
-            raise 'select a field to display' unless fields.length == 1
-            url = url.first
-            raise 'no such field' unless url.key?(fields.first)
-            url = url[fields.first]
-          end
-          raise "not url: #{url.class} #{url}" unless url.is_a?(String)
-          display_message(:data, status_image(url))
-        when :table, :csv
-          case type
-          when :config_over
-            display_table(Flattener.new(self).config_over(data), CONF_OVERVIEW_KEYS)
-          when :object_list, :single_object
-            obj_list = data
-            obj_list = [obj_list] if type.eql?(:single_object)
-            Aspera.assert_type(obj_list, Array)
-            Aspera.assert(obj_list.all?(Hash)){"expecting Array of Hash: #{obj_list.inspect}"}
-            # :object_list is an array of hash tables, where key=colum name
-            obj_list = obj_list.map{|obj|Flattener.new(self).flatten(obj)} if @options[:flat_hash]
-            display_table(obj_list, compute_fields(obj_list, fields))
-          when :value_list
-            # :value_list is a simple array of values, name of column provided in the :name
-            display_table(data.map { |i| { name => i } }, [name])
-          when :empty # no table
-            display_message(:info, special_format('empty'))
-            return
-          when :nothing # no result expected
-            Log.log.debug('no result expected')
-          when :status # no table
-            # :status displays a simple message
-            display_message(:info, data)
-          when :text # no table
-            # :status displays a simple message
-            display_message(:data, data)
-          when :other_struct # no table
-            # :other_struct is any other type of structure
-            display_message(:data, PP.pp(data, +''))
-          else
-            raise "unknown data type: #{type}"
-          end
-        else
-          raise "not expected: #{@options[:format]}"
-        end
-      end
     end
   end
 end

data/lib/aspera/cli/info.rb

@@ -12,7 +12,7 @@ module Aspera
       SRC_URL  = 'https://github.com/IBM/aspera-cli'
       # set this to warn in advance when minimum required ruby version will increase
       # see also required_ruby_version in gemspec file
-      RUBY_FUTURE_MINIMUM_VERSION = '3.0'
+      RUBY_FUTURE_MINIMUM_VERSION = '3.1'
     end
   end
 end

data/lib/aspera/cli/manager.rb

@@ -105,6 +105,7 @@ module Aspera
         # @param descr [String] description for help
         # @param to_check [Object] value to check
         # @param type_list [NilClass, Class, Array[Class]] accepted value type(s)
+        # @param check_array [bool] set to true if it is a list of values to check
         def validate_type(what, descr, to_check, type_list, check_array: false)
           return nil if type_list.nil?
           Aspera.assert(type_list.is_a?(Array) && type_list.all?(Class)){'types must be a Class Array'}