aspera-cli 4.22.0 → 4.24.0

data/lib/aspera/cli/formatter.rb

@@ -11,81 +11,15 @@ require 'terminal-table'
 require 'tty-spinner'
 require 'yaml'
 require 'pp'
+require 'csv'
 require 'word_wrap'
 
 module Aspera
   module Cli
-    # This class is used to transform a complex structure into a simple hash
-    class Flattener
-      def initialize(formatter)
-        @result = nil
-        @formatter = formatter
-      end
-
-      # General method
-      def flatten(something)
-        Aspera.assert_type(something, Hash)
-        @result = {}
-        flatten_any(something, '')
-        return @result
-      end
-
-      private
-
-      # Recursive function to flatten any type
-      # @param something [Object] to be flattened
-      # @param name [String] name of englobing key
-      def flatten_any(something, name)
-        if something.is_a?(Hash)
-          flattened_hash(something, name)
-        elsif something.is_a?(Array)
-          flatten_array(something, name)
-        elsif something.is_a?(String) && something.empty?
-          @result[name] = @formatter.special_format('empty string')
-        elsif something.nil?
-          @result[name] = @formatter.special_format('null')
-        # elsif something.eql?(true) || something.eql?(false)
-        #  @result[name] = something
-        else
-          @result[name] = something
-        end
-      end
-
-      # Recursive function to flatten an array
-      # @param array [Array] to be flattened
-      # @param name [String] name of englobing key
-      def flatten_array(array, name)
-        if array.empty?
-          @result[name] = @formatter.special_format('empty list')
-        elsif array.all?(String)
-          @result[name] = array.join("\n")
-        elsif array.all?{ |i| i.is_a?(Hash) && i.keys.eql?(%w[name])}
-          @result[name] = array.map(&:values).join(', ')
-        elsif array.all?{ |i| i.is_a?(Hash) && i.keys.sort.eql?(%w[name value])}
-          flattened_hash(array.each_with_object({}){ |i, h| h[i['name']] = i['value']}, name)
-        else
-          array.each_with_index{ |item, index| flatten_any(item, "#{name}.#{index}")}
-        end
-        nil
-      end
-
-      # Recursive function to flatten a Hash
-      # @param hash [Hash] to be flattened
-      # @param name [String] name of englobing key
-      def flattened_hash(hash, name)
-        prefix = name.empty? ? '' : "#{name}."
-        hash.each do |k, v|
-          flatten_any(v, "#{prefix}#{k}")
-        end
-      end
-    end
-
-    # Take care of output
+    # Take care of CLI output on terminal
     class Formatter
       # remove a fields from the list
       FIELDS_LESS = '-'
-      CSV_RECORD_SEPARATOR = "\n"
-      CSV_FIELD_SEPARATOR = ','
       # supported output formats
       DISPLAY_FORMATS = %i[text nagios ruby json jsonpp yaml table csv image].freeze
       # user output levels
@@ -93,34 +27,113 @@ module Aspera
       # column names for single object display in table
       SINGLE_OBJECT_COLUMN_NAMES = %i[field value].freeze
 
-      private_constant :FIELDS_LESS, :CSV_RECORD_SEPARATOR, :CSV_FIELD_SEPARATOR, :DISPLAY_FORMATS, :DISPLAY_LEVELS, :SINGLE_OBJECT_COLUMN_NAMES
+      private_constant :FIELDS_LESS, :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
       HINT_FLASH = 'HINT:'.bg_green.gray.blink.freeze
 
       class << self
-        def all_but(list)
-          list = [list] unless list.is_a?(Array)
-          return list.map{ |i| "#{FIELDS_LESS}#{i}"}.unshift(SpecialValues::ALL)
-        end
-
+        # nicer display for boolean
+        # used by spec_doc
         def tick(yes)
           result =
-            if Environment.instance.terminal_supports_unicode?
-              if yes
-                "\u2713"
-              else
-                "\u2717"
-              end
-            elsif yes
-              'Y'
+            if Environment.terminal_supports_unicode?
+              yes ? "\u2713" : "\u2717"
             else
-              ' '
+              yes ? 'Y' : ' '
             end
           return result.green if yes
           return result.red
         end
+
+        # Highlight special values on terminal
+        # empty values are dim
+        # used by spec_doc
+        def special_format(what)
+          result = "<#{what}>"
+          return %w[null empty].any?{ |s| what.include?(s)} ? result.dim : result.reverse_color
+        end
+
+        # for transfer spec table, build line for display in terminal
+        # used by spec_doc
+        def check_row(row)
+          row.each_key do |k|
+            row[k] = row[k].map{ |i| WordWrap.ww(i.to_s, 120).chomp}.join("\n") if row[k].is_a?(Array)
+          end
+        end
+
+        # used by spec_doc
+        def keyword_highlight(value)
+          value.bold
+        end
+
+        # replace empty values with a readable version
+        def enhance_display_values_hash(input_hash)
+          stack = [input_hash]
+          until stack.empty?
+            current = stack.pop
+            current.each do |key, value|
+              case value
+              when NilClass
+                current[key] = special_format('null')
+              when String
+                current[key] = special_format('empty string') if value.empty?
+              when Array
+                if value.empty?
+                  current[key] = special_format('empty list')
+                else
+                  value.each do |item|
+                    stack.push(item) if item.is_a?(Hash)
+                  end
+                end
+              when Hash
+                if value.empty?
+                  current[key] = special_format('empty dict')
+                else
+                  stack.push(value)
+                end
+              end
+            end
+          end
+        end
+
+        # Flatten a Hash into single level hash
+        def flatten_hash(input)
+          Aspera.assert_type(input, Hash)
+          return input if input.empty?
+          flat = {}
+          stack = [[nil, input]]
+          until stack.empty?
+            prefix, current = stack.pop
+            if current.respond_to?(:empty?) && current.empty?
+              flat[prefix] = current
+              next
+            end
+            case current
+            when Hash
+              current.reverse_each{ |k, v| stack.push([[prefix, k].compact.join('.'), v])}
+            when Array
+              if current.all?(String)
+                flat[prefix] = current.join("\n")
+              elsif current.all?{ |i| i.is_a?(Hash) && i.keys == ['name']}
+                flat[prefix] = current.map{ |i| i['name']}.join(', ')
+              elsif current.all?{ |i| i.is_a?(Hash) && i.keys.sort == %w[name value]}
+                stack.push([prefix, current.each_with_object({}){ |i, h| h[i['name']] = i['value']}])
+              else
+                current.each_with_index.reverse_each{ |v, k| stack.push([[prefix, k].compact.join('.'), v])}
+              end
+            else
+              flat[prefix] = current
+            end
+          end
+          flat
+        end
+
+        def all_but(list)
+          list = [list] unless list.is_a?(Array)
+          return list.map{ |i| "#{FIELDS_LESS}#{i}"}.unshift(SpecialValues::ALL)
+        end
       end
 
       # initialize the formatter
@@ -129,19 +142,6 @@ module Aspera
         @spinner = nil
       end
 
-      # Highlight special values on terminal
-      def special_format(what)
-        result = "<#{what}>"
-        return %w[null empty].any?{ |s| what.include?(s)} ? result.dim : result.reverse_color
-      end
-
-      # for transfer spec table, build line for display
-      def check_row(row)
-        row.each_key do |k|
-          row[k] = row[k].map{ |i| WordWrap.ww(i.to_s, 120).chomp}.join("\n") if row[k].is_a?(Array)
-        end
-      end
-
       # call this after REST calls if several api calls are expected
       def long_operation_running(title = '')
         return unless Environment.terminal?
@@ -159,7 +159,7 @@ module Aspera
       end
 
       def declare_options(options)
-        default_table_style = if Environment.instance.terminal_supports_unicode?
+        default_table_style = if Environment.terminal_supports_unicode?
           {border: :unicode_round}
         else
           {}
@@ -170,20 +170,22 @@ module Aspera
         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)
+          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(: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)
+          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)
+      def option_handler(option_symbol, operation, value = nil)
         Aspera.assert_values(operation, %i[set get])
         case operation
         when :set
@@ -214,11 +216,11 @@ module Aspera
       # info: additional info, displayed if level==info
       # error: always displayed on stderr
       def display_message(message_level, message, hide_secrets: true)
-        message = SecretHider.hide_secrets_in_string(message) if hide_secrets && message.is_a?(String) && hide_secrets?
+        message = SecretHider.instance.hide_secrets_in_string(message) if hide_secrets && message.is_a?(String) && hide_secrets?
         case message_level
         when :data then $stdout.puts(message) unless @options[:display].eql?(:error)
         when :info then $stdout.puts(message) if @options[:display].eql?(:info)
-        when :error then $stderr.puts(message)
+        when :error then $stderr.puts(message) # rubocop:disable Style/StderrPuts
         else Aspera.error_unexpected_value(message_level)
         end
       end
@@ -242,7 +244,7 @@ module Aspera
 
       # hides secrets in Hash or Array
       def hide_secrets(data)
-        SecretHider.deep_remove_secret(data) if hide_secrets?
+        SecretHider.instance.deep_remove_secret(data) if hide_secrets?
       end
 
       # this method displays the results, especially the table format
@@ -252,13 +254,14 @@ module Aspera
       # @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}"}
+        Log.log.debug{"display_results: type=#{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?
         hide_secrets(data)
-        data = SecretHider.hide_secrets_in_string(data) if data.is_a?(String) && hide_secrets?
+        data = SecretHider.instance.hide_secrets_in_string(data) if data.is_a?(String) && hide_secrets?
+        @options[:format] = :image if type.eql?(:image)
         case @options[:format]
         when :text
           display_message(:data, data.to_s)
@@ -273,87 +276,90 @@ module Aspera
         when :yaml
           display_message(:data, YAML.dump(filter_list_on_fields(data)))
         when :image
-          # assume it is an url
-          url = data
+          # if object or list, then must be a single
           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]
+            data = [data] if type.eql?(:single_object)
+            raise BadArgument, 'image display requires a single result' unless data.length == 1
+            fields = compute_fields(data, fields)
+            raise BadArgument, 'select a single field to display' unless fields.length == 1
+            data = data.first
+            raise BadArgument, 'no such field' unless data.key?(fields.first)
+            data = data[fields.first]
+          end
+          Aspera.assert_type(data, String){'URL or blob for image'}
+          # Check if URL
+          data =
+            begin
+              # just validate
+              URI.parse(data)
+              if Environment.instance.url_method.eql?(:text)
+                UriReader.read(data)
+              else
+                Environment.instance.open_uri(data)
+                display_message(:info, "Opened URL in browser: #{data}")
+                :done
+              end
+            rescue URI::InvalidURIError
+              data
+            end
+          # try base64
+          data = begin
+            Base64.strict_decode64(data)
+          rescue
+            data
           end
-          raise "not url: #{url.class} #{url}" unless url.is_a?(String)
-          display_message(:data, status_image(url))
+          # here, data is the image blob
+          display_message(:data, Preview::Terminal.build(data, **@options[:image].symbolize_keys)) unless data.eql?(:done)
         when :table, :csv
           case type
-          when :object_list, :single_object
-            obj_list = data
-            if type.eql?(:single_object)
-              obj_list = [obj_list]
+          when :single_object
+            # :single_object is a Hash, where key=colum name
+            Aspera.assert_type(data, Hash)
+            if data.empty?
+              display_message(:data, self.class.special_format('empty dict'))
+            else
+              data = self.class.flatten_hash(data) if @options[:flat_hash]
+              display_table([data], compute_fields([data], fields), single: true)
             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), single: type.eql?(:single_object))
+          when :object_list
+            # :object_list is an Array of Hash, where key=colum name
+            Aspera.assert_type(data, Array)
+            Aspera.assert(data.all?(Hash)){"expecting Array of Hash: #{data.inspect}"}
+            data = data.map{ |obj| self.class.flatten_hash(obj)} if @options[:flat_hash]
+            display_table(data, compute_fields(data, fields), single: type.eql?(:single_object))
           when :value_list
-            # :value_list is a simple array of values, name of column provided in the :name
+            # :value_list is a simple array of values, name of column provided in `name`
             display_table(data.map{ |i| {name => i}}, [name])
-          when :empty # no table
-            display_message(:info, special_format('empty'))
+          when :special # no table
+            if data.eql?(:nothing)
+              Log.log.debug('no result expected')
+              return
+            end
+            display_message(:info, self.class.special_format(data.to_s))
             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)
-          else
-            raise "unknown data type: #{type}"
+          else Aspera.error_unexpected_value(type){'data type'}
           end
-        else
-          raise "not expected: #{@options[:format]}"
+        else Aspera.error_unexpected_value(@options[:format]){'format'}
         end
       end
-
-      # @return text suitable to display an image from url
-      # @param blob [String] either a URL or image data
-      def status_image(blob)
-        # check if URL
-        begin
-          URI.parse(blob)
-          url = blob
-          unless Environment.instance.url_method.eql?(:text)
-            Environment.instance.open_uri(url)
-            return ''
-          end
-          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
 
+      # @return all fields of all objects in list of objects
       def all_fields(data)
         data.each_with_object({}){ |v, m| v.each_key{ |c| m[c] = true}}.keys
       end
 
       # @return the list of fields to display
-      # @param data [Array<Hash>] data to display
+      # @param data    [Array<Hash>]         data to display
       # @param default [Array<String>, Proc] list of fields to display by default (may contain special values)
       def compute_fields(data, default)
         Log.log.debug{"compute_fields: data:#{data.class} default:#{default.class} #{default}"}
@@ -412,7 +418,11 @@ module Aspera
       def filter_columns_on_select(data)
         case @options[:select]
         when Proc
-          data.select!{ |i| @options[:select].call(i)}
+          begin
+            data.select!{ |i| @options[:select].call(i)}
+          rescue Exception => e # rubocop:disable Lint/RescueException
+            raise Cli::BadArgument, "Error in user-provided ruby lambda code during select: #{e.message}"
+          end
         when Hash
           @options[:select].each{ |k, v| data.select!{ |i| i[k].eql?(v)}}
         end
@@ -423,12 +433,13 @@ module Aspera
       # @param fields        [Array] list of column names
       def display_table(object_array, fields, single: false)
         Aspera.assert(!fields.nil?){'missing fields parameter'}
-        filter_columns_on_select(object_array)
         if object_array.empty?
           # no  display for csv
-          display_message(:info, special_format('empty')) if @options[:format].eql?(:table)
+          display_message(:info, self.class.special_format('empty')) if @options[:format].eql?(:table)
           return
         end
+        filter_columns_on_select(object_array)
+        object_array.each{ |i| self.class.enhance_display_values_hash(i)}
         # if table has only one element, and only one field, display the value
         if object_array.length == 1 && fields.length == 1
           Log.log.debug("display_table: single element, field: #{fields.first}")
@@ -441,7 +452,7 @@ module Aspera
           fields = all_fields(object_array)
           single = false
         end
-        Log.log.debug{Log.dump(:object_array, object_array)}
+        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}}
         # remove empty rows
@@ -456,17 +467,29 @@ module Aspera
               display_message(:data, Terminal::Table.new(
                 headings:  SINGLE_OBJECT_COLUMN_NAMES,
                 rows:      fields.zip(row),
-                style:     @options[:table_style]&.symbolize_keys))
+                style:     @options[:table_style].symbolize_keys
+              ))
             end
           else
             # display the table ! as single table
             display_message(:data, Terminal::Table.new(
               headings:  fields,
               rows:      final_table_rows,
-              style:     @options[:table_style]&.symbolize_keys))
+              style:     @options[:table_style].symbolize_keys
+            ))
           end
         when :csv
-          display_message(:data, final_table_rows.map{ |t| t.join(CSV_FIELD_SEPARATOR)}.join(CSV_RECORD_SEPARATOR))
+          params = @options[:table_style].symbolize_keys
+          # delete default
+          params.delete(:border)
+          add_headers = params.delete(:headers)
+          output = CSV.generate(**params) do |csv|
+            csv << fields if add_headers
+            final_table_rows.each do |row|
+              csv << row
+            end
+          end
+          display_message(:data, output)
         else
           raise "not expected: #{@options[:format]}"
         end

data/lib/aspera/cli/hints.rb

@@ -3,6 +3,7 @@
 require 'aspera/transfer/error'
 require 'aspera/rest'
 require 'aspera/log'
+require 'aspera/ssh'
 require 'aspera/assert'
 require 'aspera/cli/info'
 require 'net/ssh'
@@ -36,8 +37,9 @@ module Aspera
           exception:   OpenSSL::SSL::SSLError,
           match:       /(does not match the server certificate|certificate verify failed)/,
           remediation: [
-            'You can ignore SSL errors with option:',
-            '--insecure=yes'
+            'You can ignore SSL errors with either of the following options:',
+            '--insecure=yes  (global skip)',
+            '--ignore-certificate=@list,https://<address>[:<port>]  (selective skip)'
           ]
         },
         {
@@ -64,14 +66,46 @@ module Aspera
           remediation: [
             'If remote node is Cloud Pak For Integration',
             'Make sure that a LoadBalancer is active on cluster',
-            'Check the external address of Aspera tcp-proxy pod'
+            'Check the external address of Aspera tcp-proxy Pod'
+          ]
+        },
+        {
+          exception:   Aspera::RestCallError,
+          match:       /Invalid subject\./,
+          remediation: [
+            'It seems that this user name is not registered on the server',
+            'Check the user name and try again'
+          ]
+        },
+        {
+          exception:   OpenSSL::Cipher::CipherError,
+          match:       /authentication tag already generated by cipher/,
+          remediation: [
+            'If using JRuby, refer to aspera-cli documentation.',
+            'Look for "unsupported algorithm".'
+          ]
+        },
+        {
+          exception:   OpenSSL::SSL::SSLError,
+          match:       /unexpected eof while reading/,
+          remediation: [
+            'Look at parameter ssl_options in http_options.',
+            'Refer to the manual for more information.',
+            %q{Try: --http-options=@json:'{"ssl_options":["IGNORE_UNEXPECTED_EOF"]}'}
+          ]
+        },
+        {
+          exception:   Aspera::Ssh::Error,
+          match:       /Could not chdir to home directory/,
+          remediation: [
+            'home not created in Windows?'
           ]
         }
       ]
-
       private_constant :ERROR_HINTS
 
       class << self
+        # @param error [Exception] exception object
         def hint_for(error, formatter)
           ERROR_HINTS.each do |hint|
             next unless error.is_a?(hint[:exception])