aspera-cli 4.0.0.pre1

data/lib/aspera/api_detector.rb

@@ -0,0 +1,60 @@
+require 'aspera/log'
+require 'aspera/rest'
+
+module Aspera
+  # detect Aspera product by calling API
+  class ApiDetector
+    # @return a hash: {:product=>:node,:version=>'unknown'}
+    # if not found: {:product=>:unknown,:version=>'unknown'}
+    def self.discover_product(url)
+      #uri=URI.parse(url)
+      api=Rest.new({:base_url=>url})
+      # Node
+      begin
+        result=api.call({:operation=>'GET',:subpath=>'ping'})
+        if result[:http].body.eql?('')
+          return {:product=>:node,:version=>'unknown'}
+        end
+      rescue SocketError => e
+        raise e
+      rescue => e
+        Log.log.debug("not node (#{e.class}: #{e})")
+      end
+      # AoC
+      begin
+        result=api.call({:operation=>'GET',:subpath=>'',:headers=>{'Accept'=>'text/html'}})
+        if result[:http].body.include?('content="AoC"')
+          return {:product=>:aoc,:version=>'unknown'}
+        end
+      rescue SocketError => e
+        raise e
+      rescue => e
+        Log.log.debug("not aoc (#{e.class}: #{e})")
+      end
+      # Faspex
+      begin
+        result=api.call({:operation=>'POST',:subpath=>'aspera/faspex',:headers=>{'Accept'=>'application/xrds+xml'},:text_body_params=>''})
+        if result[:http].body.start_with?('<?xml')
+          res_s=XmlSimple.xml_in(result[:http].body, {"ForceArray" => false})
+          version=res_s['XRD']['application']['version']
+          #return JSON.pretty_generate(res_s)
+        end
+        return {:product=>:faspex,:version=>version}
+      rescue
+        Log.log.debug("not faspex")
+      end
+      # Shares
+      begin
+        result=api.read('node_api/app')
+        Log.log.warn("not supposed to work")
+      rescue RestCallError => e
+        if e.response.code.to_s.eql?('401') and e.response.body.eql?('{"error":{"user_message":"API user authentication failed"}}')
+          return {:product=>:shares,:version=>'unknown'}
+        end
+        Log.log.warn("not shares: #{e.response.code} #{e.response.body}")
+      rescue
+      end
+      return {:product=>:unknown,:version=>'unknown'}
+    end
+  end
+end

data/lib/aspera/ascmd.rb

@@ -0,0 +1,151 @@
+require 'aspera/log'
+
+module Aspera
+  # Run +ascmd+ commands using specified executor (usually, remotely on transfer node)
+  # Equivalent of SDK "command client"
+  # execute: "ascmd -h" to get syntax
+  # Note: "ls" can take filters: as_ls -f *.txt -f *.bin /
+  class AsCmd
+    # list of supported actions
+    OPERATIONS=[:ls,:rm,:mv,:du,:info,:mkdir,:cp,:df,:md5sum]
+
+    #  @param command_executor [Object] provides the "execute" method, taking a command to execute, and stdin to feed to it, typically: ssh or local
+    def initialize(command_executor)
+      @command_executor = command_executor
+    end
+
+    # execute an "as" command on a remote server
+    # @param [Symbol] one of OPERATIONS
+    # @param [Array] parameters for "as" command
+    # @return result of command, type depends on command (bool, array, hash)
+    def execute_single(action_sym,args=nil)
+      # concatenate arguments, enclose in double quotes, protect backslash and double quotes, add "as_" command and as_exit
+      stdin_input=(args||[]).map{|v| '"' + v.gsub(/["\\]/n) {|s| '\\' + s } + '"'}.unshift('as_'+action_sym.to_s).join(' ')+"\nas_exit\n"
+      # execute, get binary output
+      bytebuffer=@command_executor.execute('ascmd',stdin_input).unpack('C*')
+      # get hash or table result
+      result=self.class.parse(bytebuffer,:result)
+      raise "ERROR: unparsed bytes remaining" unless bytebuffer.empty?
+      # get and delete info,always present in results
+      system_info=result[:info]
+      result.delete(:info)
+      # make single file result like a folder
+      if result.has_key?(:file);result[:dir]=[result[:file]];result.delete(:file);end
+      # add type field for stats
+      if result.has_key?(:dir)
+        result[:dir].each do |file|
+          if file.has_key?(:smode)
+            # Converts the first character of the file mode (see 'man ls') into a type.
+            file[:type]=case file[:smode][0,1];when'd';:directory;when'-';:file;when'l';:link;else;:other;end
+          end
+        end
+      end
+      # for info, second overrides first, so restore it
+      case result.keys.length;when 0;result=system_info;when 1;result=result[result.keys.first];else raise "error";end
+      # raise error as exception
+      raise Error.new(result[:errno],result[:errstr],action_sym,args) if result.is_a?(Hash) and result.keys.sort == TYPES_DESCR[:error][:fields].map{|i|i[:name]}.sort
+      return result
+    end # execute_single
+
+    # This exception is raised when +ascmd+ returns an error.
+    class Error < StandardError
+      attr_reader :errno, :errstr, :command, :args
+      def initialize(errno,errstr,cmd,args);@errno=errno;@errstr=errstr;@command=cmd;@args=args;end
+
+      def message; "ascmd: (#{errno}) #{errstr}"; end
+
+      def extended_message; "ascmd: errno=#{errno} errstr=\"#{errstr}\" command=\"#{command}\" args=#{args}"; end
+    end # Error
+
+    private
+
+    # description of result structures (see ascmdtypes.h). Base types are big endian
+    # key = name of type
+    TYPES_DESCR={
+      :result  =>{:decode=>:field_list,:fields=>[{:name=>:file,:is_a=>:stat},{:name=>:dir,:is_a=>:stat,:special=>:substruct},{:name=>:size,:is_a=>:size},{:name=>:error,:is_a=>:error},{:name=>:info,:is_a=>:info},{:name=>:success,:is_a=>nil,:special=>:return_true},{:name=>:exit,:is_a=>nil},{:name=>:df,:is_a=>:mnt,:special=>:restart_on_first},{:name=>:md5sum,:is_a=>:md5sum}]},
+      :stat    =>{:decode=>:field_list,:fields=>[{:name=>:name,:is_a=>:zstr},{:name=>:size,:is_a=>:int64},{:name=>:mode,:is_a=>:int32,:check=>nil},{:name=>:zmode,:is_a=>:zstr},{:name=>:uid,:is_a=>:int32,:check=>nil},{:name=>:zuid,:is_a=>:zstr},{:name=>:gid,:is_a=>:int32,:check=>nil},{:name=>:zgid,:is_a=>:zstr},{:name=>:ctime,:is_a=>:epoch},{:name=>:zctime,:is_a=>:zstr},{:name=>:mtime,:is_a=>:epoch},{:name=>:zmtime,:is_a=>:zstr},{:name=>:atime,:is_a=>:epoch},{:name=>:zatime,:is_a=>:zstr},{:name=>:symlink,:is_a=>:zstr},{:name=>:errno,:is_a=>:int32},{:name=>:errstr,:is_a=>:zstr}]},
+      :info    =>{:decode=>:field_list,:fields=>[{:name=>:platform,:is_a=>:zstr},{:name=>:version,:is_a=>:zstr},{:name=>:lang,:is_a=>:zstr},{:name=>:territory,:is_a=>:zstr},{:name=>:codeset,:is_a=>:zstr},{:name=>:lc_ctype,:is_a=>:zstr},{:name=>:lc_numeric,:is_a=>:zstr},{:name=>:lc_time,:is_a=>:zstr},{:name=>:lc_all,:is_a=>:zstr},{:name=>:dev,:is_a=>:zstr,:special=>:multiple},{:name=>:browse_caps,:is_a=>:zstr},{:name=>:protocol,:is_a=>:zstr}]},
+      :size    =>{:decode=>:field_list,:fields=>[{:name=>:size,:is_a=>:int64},{:name=>:fcount,:is_a=>:int32},{:name=>:dcount,:is_a=>:int32},{:name=>:failed_fcount,:is_a=>:int32},{:name=>:failed_dcount,:is_a=>:int32}]},
+      :error   =>{:decode=>:field_list,:fields=>[{:name=>:errno,:is_a=>:int32},{:name=>:errstr,:is_a=>:zstr}]},
+      :mnt     =>{:decode=>:field_list,:fields=>[{:name=>:fs,:is_a=>:zstr},{:name=>:dir,:is_a=>:zstr},{:name=>:is_a,:is_a=>:zstr},{:name=>:total,:is_a=>:int64},{:name=>:used,:is_a=>:int64},{:name=>:free,:is_a=>:int64},{:name=>:fcount,:is_a=>:int64},{:name=>:errno,:is_a=>:int32},{:name=>:errstr,:is_a=>:zstr}]},
+      :md5sum  =>{:decode=>:field_list,:fields=>[{:name=>:md5sum,:is_a=>:zstr}]},
+      :int8    =>{:decode=>:base,:unpack=>'C',:size=>1},
+      :int32   =>{:decode=>:base,:unpack=>'L>',:size=>4},
+      :int64   =>{:decode=>:base,:unpack=>'Q>',:size=>8},
+      :epoch   =>{:decode=>:base,:unpack=>'Q>',:size=>8},
+      :zstr    =>{:decode=>:base,:unpack=>'Z*'},
+      :blist   =>{:decode=>:buffer_list}
+    }
+
+    # protocol enum start at one, but array index start at zero
+    ENUM_START=1
+
+    private_constant :TYPES_DESCR,:ENUM_START
+
+    # get description of structure's field, @param struct_name, @param typed_buffer provides field name
+    def self.field_description(struct_name,typed_buffer)
+      result=TYPES_DESCR[struct_name][:fields][typed_buffer[:btype]-ENUM_START]
+      raise "Unrecognized field for #{struct_name}: #{typed_buffer[:btype]}\n#{typed_buffer[:buffer]}" if result.nil?
+      return result
+    end
+
+    # decodes the provided buffer as provided type name
+    # @return a decoded type.
+    # :base : value, :buffer_list : an array of {btype,buffer}, :field_list : a hash, or array
+    def self.parse(buffer,type_name,indent_level=nil)
+      indent_level=(indent_level||-1)+1
+      type_descr=TYPES_DESCR[type_name]
+      raise "Unexpected type #{type_name}" if type_descr.nil?
+      Log.log.debug("#{"   ."*indent_level}parse:#{type_name}:#{type_descr[:decode]}:#{buffer[0,16]}...".red)
+      result=nil
+      case type_descr[:decode]
+      when :base
+        num_bytes=type_name.eql?(:zstr) ? buffer.length : type_descr[:size]
+        raise "ERROR:not enough bytes" if buffer.length < num_bytes
+        byte_array=buffer.shift(num_bytes);byte_array=[byte_array] unless byte_array.is_a?(Array)
+        result=byte_array.pack('C*').unpack(type_descr[:unpack]).first
+        Log.log.debug("#{"   ."*indent_level}-> base:#{byte_array} -> #{result}")
+        result=Time.at(result) if type_name.eql?(:epoch)
+      when :buffer_list
+        result = []
+        while !buffer.empty?
+          btype=parse(buffer,:int8,indent_level)
+          length=parse(buffer,:int32,indent_level)
+          raise "ERROR:not enough bytes" if buffer.length < length
+          value=buffer.shift(length)
+          result.push({:btype=>btype,:buffer=>value})
+          Log.log.debug("#{"   ."*indent_level}:buffer_list[#{result.length-1}] #{result.last}")
+        end
+      when :field_list
+        # by default the result is one struct
+        result = {}
+        # get individual binary fields
+        parse(buffer,:blist,indent_level).each do |typed_buffer|
+          # what type of field is it ?
+          field_info=field_description(type_name,typed_buffer)
+          Log.log.debug("#{"   ."*indent_level}+ field(special=#{field_info[:special]})=#{field_info[:name]}".green)
+          case field_info[:special]
+          when nil
+            result[field_info[:name]]=parse(typed_buffer[:buffer],field_info[:is_a],indent_level)
+          when :return_true
+            result[field_info[:name]]=true
+          when :substruct
+            result[field_info[:name]]=parse(typed_buffer[:buffer],:blist,indent_level).map{|r|parse(r[:buffer],field_info[:is_a],indent_level)}
+          when :multiple
+            result[field_info[:name]]||=[]
+            result[field_info[:name]].push(parse(typed_buffer[:buffer],field_info[:is_a],indent_level))
+          when :restart_on_first
+            fl=result[field_info[:name]]=[]
+            parse(typed_buffer[:buffer],:blist,indent_level).map do |tb|
+              fl.push({}) if tb[:btype].eql?(ENUM_START)
+              fi=field_description(field_info[:is_a],tb)
+              fl.last[fi[:name]]=parse(tb[:buffer],fi[:is_a],indent_level)
+            end
+          end
+        end
+      else raise "error: unknown decode:#{type_descr[:decode]}"
+      end # is_a
+      return result
+    end
+  end
+end

data/lib/aspera/ats_api.rb

@@ -0,0 +1,43 @@
+require 'aspera/log'
+require 'aspera/rest'
+
+module Aspera
+  class AtsApi < Rest
+    # currently supported clouds
+    # Note to Aspera: shall be an API call
+    CLOUD_NAME={
+      :aws =>'Amazon Web Services',
+      :azure =>'Microsoft Azure',
+      :google =>'Google Cloud',
+      :limelight =>'Limelight',
+      :rackspace =>'Rackspace',
+      :softlayer =>'IBM Cloud'
+    }
+    
+    private_constant :CLOUD_NAME
+    
+    def self.base_url;'https://ats.aspera.io';end
+
+    def initialize
+      super({:base_url=>AtsApi.base_url+'/pub/v1'})
+      # cache of server data
+      @all_servers_cache=nil
+    end
+    
+    def cloud_names;CLOUD_NAME;end
+
+    # all available ATS servers
+    # NOTE to Aspera: an API shall be created to retrieve all servers at once
+    def all_servers
+      if @all_servers_cache.nil?
+        @all_servers_cache=[]
+        CLOUD_NAME.keys.each do |name|
+          read("servers/#{name.to_s.upcase}")[:data].each do |i|
+            @all_servers_cache.push(i)
+          end
+        end
+      end
+      return @all_servers_cache
+    end
+  end # AtsApi
+end # Aspera

data/lib/aspera/cli/basic_auth_plugin.rb

@@ -0,0 +1,38 @@
+require 'aspera/rest'
+require 'aspera/cli/plugin'
+
+module Aspera
+  module Cli
+    # base class for applications supporting basic authentication
+    class BasicAuthPlugin < Plugin
+      def initialize(env)
+        super(env)
+        unless env[:skip_basic_auth_options]
+          self.options.add_opt_simple(:url,"URL of application, e.g. https://org.asperafiles.com")
+          self.options.add_opt_simple(:username,"username to log in")
+          self.options.add_opt_simple(:password,"user's password")
+          self.options.parse_options!
+        end
+      end
+      ACTIONS=[]
+
+      def execute_action
+        raise "do not execute action on this generic plugin"
+      end
+
+      # returns a Rest object with basic auth
+      def basic_auth_api(subpath=nil)
+        api_url=self.options.get_option(:url,:mandatory)
+        api_url=api_url+'/'+subpath unless subpath.nil?
+        return Rest.new({
+          :base_url => api_url,
+          :auth     => {
+          :type     => :basic,
+          :username => self.options.get_option(:username,:mandatory),
+          :password => self.options.get_option(:password,:mandatory)
+          }})
+      end
+
+    end # BasicAuthPlugin
+  end # Cli
+end # Aspera

data/lib/aspera/cli/extended_value.rb

@@ -0,0 +1,88 @@
+require 'aspera/cli/plugins/config'
+require 'json'
+require 'base64'
+require 'zlib'
+require 'csv'
+require 'singleton'
+
+module Aspera
+  module Cli
+    # command line extended values
+    class ExtendedValue
+      include Singleton
+      private
+      # decode comma separated table text
+      def self.decode_csvt(value)
+        col_titles=nil
+        hasharray=[]
+        CSV.parse(value).each do |values|
+          next if values.empty?
+          if col_titles.nil?
+            col_titles=values
+          else
+            entry={}
+            col_titles.each{|title|entry[title]=values.shift}
+            hasharray.push(entry)
+          end
+        end
+        value=hasharray
+      end
+
+      def initialize
+        @handlers={
+          :decoder=>{
+          'base64' =>lambda{|v|Base64.decode64(v)},
+          'json'   =>lambda{|v|JSON.parse(v)},
+          'zlib'   =>lambda{|v|Zlib::Inflate.inflate(v)},
+          'ruby'   =>lambda{|v|eval(v)},
+          'csvt'   =>lambda{|v|ExtendedValue.decode_csvt(v)},
+          'lines'  =>lambda{|v|v.split("\n")},
+          'list'   =>lambda{|v|v[1..-1].split(v[0])}
+          },
+          :reader=>{
+          'val'    =>lambda{|v|v},
+          'file'   =>lambda{|v|File.read(File.expand_path(v))},
+          'path'   =>lambda{|v|File.expand_path(v)},
+          'env'    =>lambda{|v|ENV[v]},
+          'stdin'  =>lambda{|v|raise "no value allowed for stdin" unless v.empty?;STDIN.read}
+          }
+          # other handlers can be set using set_handler, e.g. preset is reader in config plugin
+        }
+      end
+      public
+
+      def modifiers;@handlers.keys.map{|i|@handlers[i].keys}.flatten;end
+
+      # add a new :reader or :decoder
+      # decoder can be chained, reader is last one on right
+      def set_handler(name,type,method)
+        raise "type must be one of #{@handlers.keys}" unless @handlers.keys.include?(type)
+        Log.log.debug("setting #{type} handler for #{name}")
+        @handlers[type][name]=method
+      end
+
+      # parse an option value if it is a String using supported extended value modifiers
+      # other value types are returned as is
+      def evaluate(value)
+        return value if !value.is_a?(String)
+        # first determine decoders, in reversed order
+        decoders_reversed=[]
+        while (m=value.match(/^@([^:]+):(.*)/)) and @handlers[:decoder].include?(m[1])
+          decoders_reversed.unshift(m[1])
+          value=m[2]
+        end
+        # then read value
+        @handlers[:reader].each do |reader,method|
+          if m=value.match(/^@#{reader}:(.*)/) then
+            value=method.call(m[1])
+            break
+          end
+        end
+        decoders_reversed.each do |decoder|
+          value=@handlers[:decoder][decoder].call(value)
+        end
+        return value
+      end # parse
+    end
+  end
+end

data/lib/aspera/cli/formater.rb

@@ -0,0 +1,238 @@
+#require 'text-table'
+require 'terminal-table'
+
+#require 'fileutils'
+require 'yaml'
+require 'pp'
+
+module Aspera
+  module Cli
+    # Take care of output
+    class Formater
+      FIELDS_ALL='ALL'
+      FIELDS_DEFAULT='DEF'
+      # supported output formats
+      DISPLAY_FORMATS=[:table,:ruby,:json,:jsonpp,:yaml,:csv,:nagios]
+      # user output levels
+      DISPLAY_LEVELS=[:info,:data,:error]
+      CSV_RECORD_SEPARATOR="\n"
+      CSV_FIELD_SEPARATOR=","
+
+      private_constant :FIELDS_ALL,:FIELDS_DEFAULT,:DISPLAY_FORMATS,:DISPLAY_LEVELS,:CSV_RECORD_SEPARATOR,:CSV_FIELD_SEPARATOR
+      attr_accessor :option_flat_hash
+
+      def initialize(opt_mgr)
+        @option_flat_hash=true
+        @opt_mgr=opt_mgr
+        @opt_mgr.set_obj_attr(:flat_hash,self,:option_flat_hash)
+        @opt_mgr.add_opt_list(:format,DISPLAY_FORMATS,"output format")
+        @opt_mgr.add_opt_list(:display,DISPLAY_LEVELS,"output only some information")
+        @opt_mgr.add_opt_simple(:fields,"comma separated list of fields, or #{FIELDS_ALL}, or #{FIELDS_DEFAULT}")
+        @opt_mgr.add_opt_simple(:select,"select only some items in lists, extended value: hash (column, value)")
+        @opt_mgr.add_opt_simple(:table_style,"table display style")
+        @opt_mgr.add_opt_boolean(:flat_hash,"display hash values as additional keys")
+        @opt_mgr.set_option(:format,:table)
+        @opt_mgr.set_option(:display,:info)
+        @opt_mgr.set_option(:fields,FIELDS_DEFAULT)
+        @opt_mgr.set_option(:table_style,':.:')
+      end
+
+      # main output method
+      def display_message(message_level,message)
+        display_level=@opt_mgr.get_option(:display,:mandatory)
+        case message_level
+        when :info; STDOUT.puts(message) if display_level.eql?(:info)
+        when :data; STDOUT.puts(message) unless display_level.eql?(:error)
+        when :error; STDERR.puts(message)
+        else raise "wrong message_level:#{message_level}"
+        end
+      end
+
+      def display_status(status)
+        display_message(:info,status)
+      end
+
+      # @param source [Hash] hash to modify
+      # @param keep_last [bool]
+      def self.flatten_object(source,keep_last)
+        newval={}
+        flatten_sub_hash_rec(source,keep_last,'',newval)
+        source.clear
+        source.merge!(newval)
+      end
+
+      # recursive function to modify a hash
+      # @param source [Hash] to be modified
+      # @param keep_last [bool] truer if last level is not
+      # @param prefix [String] true if last level is not
+      # @param dest [Hash] new hash flattened
+      def self.flatten_sub_hash_rec(source,keep_last,prefix,dest)
+        #is_simple_hash=source.is_a?(Hash) and source.values.inject(true){|m,v| xxx=!v.respond_to?(:each) and m;puts("->#{xxx}>#{v.respond_to?(:each)} #{v}-");xxx}
+        is_simple_hash=false
+        Log.log.debug("(#{keep_last})[#{is_simple_hash}] -#{source.values}- \n-#{source}-")
+        return source if keep_last and is_simple_hash
+        source.each do |k,v|
+          if v.is_a?(Hash) and ( !keep_last or !is_simple_hash )
+            flatten_sub_hash_rec(v,keep_last,prefix+k.to_s+'.',dest)
+          else
+            dest[prefix+k.to_s]=v
+          end
+        end
+        return nil
+      end
+
+      # special for Aspera on Cloud display node
+      # {"param" => [{"name"=>"foo","value"=>"bar"}]} will be expanded to {"param.foo" : "bar"}
+      def self.flatten_name_value_list(hash)
+        hash.keys.each do |k|
+          v=hash[k]
+          if v.is_a?(Array) and v.map{|i|i.class}.uniq.eql?([Hash]) and v.map{|i|i.keys}.flatten.sort.uniq.eql?(["name", "value"])
+            v.each do |pair|
+              hash["#{k}.#{pair["name"]}"]=pair["value"]
+            end
+            hash.delete(k)
+          end
+        end
+      end
+
+      def result_default_fields(results,table_rows_hash_val)
+        if results.has_key?(:fields) and !results[:fields].nil?
+          final_table_columns=results[:fields]
+        else
+          if !table_rows_hash_val.empty?
+            final_table_columns=table_rows_hash_val.first.keys
+          else
+            final_table_columns=['empty']
+          end
+        end
+      end
+
+      def result_all_fields(results,table_rows_hash_val)
+        raise "internal error: must be array" unless table_rows_hash_val.is_a?(Array)
+        # get the list of all column names used in all lines, not just frst one, as all lines may have different columns
+        return table_rows_hash_val.inject({}){|m,v|v.keys.each{|c|m[c]=true};m}.keys
+      end
+
+      # this method displays the results, especially the table format
+      def display_results(results)
+        raise "INTERNAL ERROR, result must be Hash (got: #{results.class}: #{results})" unless results.is_a?(Hash)
+        raise "INTERNAL ERROR, result must have type" unless results.has_key?(:type)
+        raise "INTERNAL ERROR, result must have data" unless results.has_key?(:data) or [:empty,:nothing].include?(results[:type])
+        res_data=results[:data]
+        # comma separated list in string format
+        user_asked_fields_list_str=@opt_mgr.get_option(:fields,:mandatory)
+        display_format=@opt_mgr.get_option(:format,:mandatory)
+        case display_format
+        when :nagios
+          Nagios.process(res_data)
+        when :ruby
+          display_message(:data,PP.pp(res_data,''))
+        when :json
+          display_message(:data,JSON.generate(res_data))
+        when :jsonpp
+          display_message(:data,JSON.pretty_generate(res_data))
+        when :yaml
+          display_message(:data,res_data.to_yaml)
+        when :table,:csv
+          case results[:type]
+          when :object_list # goes to table display
+            raise "internal error: unexpected type: #{res_data.class}, expecting Array" unless res_data.is_a?(Array)
+            # :object_list is an array of hash tables, where key=colum name
+            table_rows_hash_val = res_data
+            final_table_columns=nil
+            if @option_flat_hash
+              table_rows_hash_val.each do |obj|
+                self.class.flatten_object(obj,results[:option_expand_last])
+              end
+            end
+            final_table_columns=case user_asked_fields_list_str
+            when FIELDS_DEFAULT; result_default_fields(results,table_rows_hash_val)
+            when FIELDS_ALL;     result_all_fields(results,table_rows_hash_val)
+            else
+              if user_asked_fields_list_str.start_with?('+')
+                result_default_fields(results,table_rows_hash_val).push(*user_asked_fields_list_str.gsub(/^\+/,'').split(','))
+              else
+                user_asked_fields_list_str.split(',')
+              end
+            end
+          when :single_object # goes to table display
+            # :single_object is a simple hash table  (can be nested)
+            raise "internal error: expecting Hash: got #{res_data.class}: #{res_data}" unless res_data.is_a?(Hash)
+            final_table_columns = results[:columns] || ['key','value']
+            if @option_flat_hash
+              self.class.flatten_object(res_data,results[:option_expand_last])
+              self.class.flatten_name_value_list(res_data)
+            end
+            asked_fields=case user_asked_fields_list_str
+            when FIELDS_DEFAULT; results[:fields]||res_data.keys
+            when FIELDS_ALL;     res_data.keys
+            else                 user_asked_fields_list_str.split(',')
+            end
+            table_rows_hash_val=asked_fields.map { |i| { final_table_columns.first => i, final_table_columns.last => res_data[i] } }
+          when :value_list  # goes to table display
+            # :value_list is a simple array of values, name of column provided in the :name
+            final_table_columns = [results[:name]]
+            table_rows_hash_val=res_data.map { |i| { results[:name] => i } }
+          when :empty # no table
+            display_message(:info,'empty')
+            return
+          when :nothing # no result expected
+            Log.log.debug("no result expected")
+            return
+          when :status # no table
+            # :status displays a simple message
+            display_message(:info,res_data)
+            return
+          when :text # no table
+            # :status displays a simple message
+            display_message(:data,res_data)
+            return
+          when :other_struct # no table
+            # :other_struct is any other type of structure
+            display_message(:data,PP.pp(res_data,''))
+            return
+          else
+            raise "unknown data type: #{results[:type]}"
+          end
+          # here we expect: table_rows_hash_val and final_table_columns
+          raise "no field specified" if final_table_columns.nil?
+          if table_rows_hash_val.empty?
+            display_message(:info,'empty'.gray) unless display_format.eql?(:csv)
+            return
+          end
+          # convert to string with special function. here table_rows_hash_val is an array of hash
+          table_rows_hash_val=results[:textify].call(table_rows_hash_val) if results.has_key?(:textify)
+          filter=@opt_mgr.get_option(:select,:optional)
+          unless filter.nil?
+            raise CliBadArgument,"expecting hash for select" unless filter.is_a?(Hash)
+            filter.each{|k,v|table_rows_hash_val.select!{|i|i[k].eql?(v)}}
+          end
+
+          # convert data to string, and keep only display fields
+          final_table_rows=table_rows_hash_val.map { |r| final_table_columns.map { |c| r[c].to_s } }
+          # here : final_table_columns : list of column names
+          # here: final_table_rows : array of list of value
+          case display_format
+          when :table
+            style=@opt_mgr.get_option(:table_style,:mandatory).split('')
+            # display the table !
+            #display_message(:data,Text::Table.new(
+            #:head => final_table_columns,
+            #:rows => final_table_rows,
+            #:horizontal_boundary   => style[0],
+            #:vertical_boundary     => style[1],
+            #:boundary_intersection => style[2]))
+            display_message(:data,Terminal::Table.new(
+            :headings => final_table_columns,
+            :rows     => final_table_rows,
+            :border_x => style[0],
+            :border_y => style[1],
+            :border_i => style[2]))
+          when :csv
+            display_message(:data,final_table_rows.map{|t| t.join(CSV_FIELD_SEPARATOR)}.join(CSV_RECORD_SEPARATOR))
+          end
+        end
+      end
+    end
+  end
+end