aspera-cli 4.5.0 → 4.8.0

data/lib/aspera/cli/formater.rb

@@ -1,7 +1,7 @@
-#require 'text-table'
-require 'terminal-table'
+# frozen_string_literal: true
 
-#require 'fileutils'
+require 'aspera/secret_hider'
+require 'terminal-table'
 require 'yaml'
 require 'pp'
 
@@ -9,41 +9,105 @@ module Aspera
   module Cli
     # Take care of output
     class Formater
-      FIELDS_ALL='ALL'
-      FIELDS_DEFAULT='DEF'
+      FIELDS_ALL = 'ALL'
+      FIELDS_DEFAULT = 'DEF'
+      CSV_RECORD_SEPARATOR = "\n"
+      CSV_FIELD_SEPARATOR = ','
       # supported output formats
-      DISPLAY_FORMATS=[:table,:ruby,:json,:jsonpp,:yaml,:csv,:nagios]
+      DISPLAY_FORMATS = %i[table ruby json jsonpp yaml csv nagios].freeze
       # user output levels
-      DISPLAY_LEVELS=[:info,:data,:error]
-      CSV_RECORD_SEPARATOR="\n"
-      CSV_FIELD_SEPARATOR=","
+      DISPLAY_LEVELS = %i[info data error].freeze
+      CONF_OVERVIEW_KEYS=%w[config parameter value].freeze
+
+      private_constant :FIELDS_ALL,:FIELDS_DEFAULT,:DISPLAY_FORMATS,:DISPLAY_LEVELS,:CSV_RECORD_SEPARATOR,:CSV_FIELD_SEPARATOR,
+        :CONF_OVERVIEW_KEYS
+
+      class << self
+        # special for Aspera on Cloud display node
+        # {"param" => [{"name"=>"foo","value"=>"bar"}]} will be expanded to {"param.foo" : "bar"}
+        def flatten_name_value_list(hash)
+          hash.keys.each do |k|
+            v = hash[k]
+            next unless v.is_a?(Array) && v.map(&:class).uniq.eql?([Hash]) && v.map(&:keys).flatten.sort.uniq.eql?(%w[name value])
+            v.each do |pair|
+              hash["#{k}.#{pair['name']}"] = pair['value']
+            end
+            hash.delete(k)
+          end
+        end
+
+        def flatten_config_overview(conffile)
+          r = []
+          conffile.each do |config,preset|
+            preset.each do |parameter,value|
+              r.push(CONF_OVERVIEW_KEYS.zip([config,parameter,value]).to_h)
+            end
+          end
+          return r
+        end
 
-      private_constant :FIELDS_ALL,:FIELDS_DEFAULT,:DISPLAY_FORMATS,:DISPLAY_LEVELS,:CSV_RECORD_SEPARATOR,:CSV_FIELD_SEPARATOR
-      attr_accessor :option_flat_hash
+        def simple_hash?(h)
+          !(h.values.any?{|v|[Hash,Array].any?{|c|v.is_a?(c)}})
+        end
 
+        # recursive function to modify a hash
+        # @param source [Hash] to be modified
+        # @param expand_last [bool] truer if last level is not
+        # @param result [Hash] new hash flattened
+        # @param prefix [String] true if last level is not
+        def flattened_object(source,result: {},prefix: '',expand_last: false)
+          Log.log.debug("(#{expand_last})[#{simple_hash?(source)}] -#{source.values}- \n-#{source}-")
+          source.each do |k,v|
+            if v.is_a?(Hash) && !(expand_last && simple_hash?(v))
+              flattened_object(v,result: result,prefix: prefix + k.to_s + '.',expand_last: expand_last)
+            else
+              result[prefix + k.to_s] = v
+            end
+          end
+          return result
+        end
+      end
+
+      attr_accessor :option_flat_hash,:option_transpose_single,:option_format,:option_display,:option_fields,:option_table_style,
+        :option_select,:option_show_secrets
+
+      # adds options but does not parse
       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,':.:')
+        @option_format = :table
+        @option_display = :info
+        @option_fields = FIELDS_DEFAULT
+        @option_select = nil
+        @option_table_style = ':.:'
+        @option_flat_hash = true
+        @option_transpose_single = true
+        @option_show_secrets = false
+        opt_mgr.set_obj_attr(:format,self,:option_format)
+        opt_mgr.set_obj_attr(:display,self,:option_display)
+        opt_mgr.set_obj_attr(:fields,self,:option_fields)
+        opt_mgr.set_obj_attr(:select,self,:option_select)
+        opt_mgr.set_obj_attr(:table_style,self,:option_table_style)
+        opt_mgr.set_obj_attr(:flat_hash,self,:option_flat_hash)
+        opt_mgr.set_obj_attr(:transpose_single,self,:option_transpose_single)
+        opt_mgr.set_obj_attr(:show_secrets,self,:option_show_secrets)
+        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.add_opt_boolean(:transpose_single,'single object fields output vertically')
+        opt_mgr.add_opt_boolean(:show_secrets,'show secrets on command output')
       end
 
       # main output method
+      # data: for requested data, not displayed if level==error
+      # info: additional info, displayed if level==info
+      # error: always displayed on stderr
       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)
+        when :data then $stdout.puts(message) unless @option_display.eql?(:error)
+        when :info then $stdout.puts(message) if @option_display.eql?(:info)
+        when :error then $stderr.puts(message)
         else raise "wrong message_level:#{message_level}"
         end
       end
@@ -52,81 +116,41 @@ module Aspera
         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']
+        unless results[:fields].nil?
+          raise "internal error: [fields] must be Array, not #{results[:fields].class}" unless results[:fields].is_a?(Array)
+          if results[:fields].first.eql?(:all_but) && !table_rows_hash_val.empty?
+            filter = results[:fields][1..-1]
+            return table_rows_hash_val.first.keys.reject{|i|filter.include?(i)}
           end
+          return results[:fields]
         end
+        return ['empty'] if table_rows_hash_val.empty?
+        return table_rows_hash_val.first.keys
       end
 
-      def result_all_fields(results,table_rows_hash_val)
-        raise "internal error: must be array" unless table_rows_hash_val.is_a?(Array)
+      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
+        return table_rows_hash_val.each_with_object({}){|v,m|v.keys.each{|c|m[c] = true};}.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]
+        raise 'INTERNAL ERROR, result must have type' unless results.has_key?(:type)
+        raise 'INTERNAL ERROR, result must have data' unless results.has_key?(:data) || %i[empty nothing].include?(results[:type])
+        res_data = results[:data]
+        # for config overvuew, it is name and value
+        is_config_overview = res_data.is_a?(Array) && !res_data.empty? && res_data.first.is_a?(Hash) && res_data.first.keys.sort.eql?(CONF_OVERVIEW_KEYS)
+        SecretHider.deep_remove_secret(res_data, is_name_value: is_config_overview) unless @option_show_secrets || @option_display.eql?(: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
+        user_asked_fields_list_str = @option_fields
+        case @option_format
         when :nagios
           Nagios.process(res_data)
         when :ruby
-          display_message(:data,PP.pp(res_data,''))
+          display_message(:data,PP.pp(res_data,+''))
         when :json
           display_message(:data,JSON.generate(res_data))
         when :jsonpp
@@ -134,52 +158,56 @@ module Aspera
         when :yaml
           display_message(:data,res_data.to_yaml)
         when :table,:csv
+          if !@option_transpose_single && results[:type].eql?(:single_object)
+            results[:type] = :object_list
+            res_data = [res_data]
+          end
           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
+            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
+              table_rows_hash_val.map!{|obj|self.class.flattened_object(obj,expand_last: results[:option_expand_last])}
             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(','))
-              elsif user_asked_fields_list_str.start_with?('-')
-                result_default_fields(results,table_rows_hash_val).select{|i| ! user_asked_fields_list_str.gsub(/^\-/,'').split(',').include?(i)}
+            final_table_columns =
+              case user_asked_fields_list_str
+              when FIELDS_DEFAULT then result_default_fields(results,table_rows_hash_val)
+              when FIELDS_ALL then     result_all_fields(results,table_rows_hash_val)
               else
-                user_asked_fields_list_str.split(',')
+                if user_asked_fields_list_str.start_with?('+')
+                  result_default_fields(results,table_rows_hash_val).push(*user_asked_fields_list_str.gsub(/^\+/,'').split(','))
+                elsif user_asked_fields_list_str.start_with?('-')
+                  result_default_fields(results,table_rows_hash_val).reject{|i| user_asked_fields_list_str.gsub(/^-/,'').split(',').include?(i)}
+                else
+                  user_asked_fields_list_str.split(',')
+                end
               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']
+            final_table_columns = results[:columns] || %w[key value]
             if @option_flat_hash
-              self.class.flatten_object(res_data,results[:option_expand_last])
+              res_data=self.class.flattened_object(res_data,expand_last: 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
+            asked_fields =
+              case user_asked_fields_list_str
+              when FIELDS_DEFAULT then results[:fields] || res_data.keys
+              when FIELDS_ALL then     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 } }
+            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")
+            Log.log.debug('no result expected')
             return
           when :status # no table
             # :status displays a simple message
@@ -191,45 +219,43 @@ module Aspera
             return
           when :other_struct # no table
             # :other_struct is any other type of structure
-            display_message(:data,PP.pp(res_data,''))
+            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?
+          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)
+            display_message(:info,'empty'.gray) unless @option_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)}}
+          table_rows_hash_val = results[:textify].call(table_rows_hash_val) if results.has_key?(:textify)
+          unless @option_select.nil? || (@option_select.respond_to?(:empty?) && @option_select.empty?)
+            raise CliBadArgument,"expecting hash for select, have #{@option_select.class}: #{@option_select}" unless @option_select.is_a?(Hash)
+            @option_select.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 } }
+          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
+          case @option_format
           when :table
-            style=@opt_mgr.get_option(:table_style,:mandatory).split('')
+            style = @option_table_style.chars
             # 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]))
+            #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]))
+              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

data/lib/aspera/cli/info.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Aspera
+  module Cli
+    # name of command line tool, also used as foldername where config is stored
+    PROGRAM_NAME = 'ascli'
+    # name of the containing gem, same as in <gem name>.gemspec
+    GEM_NAME = 'aspera-cli'
+    DOC_URL  = "https://www.rubydoc.info/gems/#{GEM_NAME}"
+    GEM_URL  = "https://rubygems.org/gems/#{GEM_NAME}"
+    SRC_URL  = 'https://github.com/IBM/aspera-cli'
+    # set this to warn in advance when minimum required ruby version will increase
+    # for example currently minimum version is 2.4 in gemspec, but future minimum will be 2.5
+    # set to currenmt minimum if there is no deprecation
+    # the actual current minimum required version is in gemspec at required_ruby_version
+    RUBY_FUTURE_MINIMUM_VERSION = '2.5'
+  end
+end

data/lib/aspera/cli/listener/line_dump.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'aspera/fasp/listener'
 require 'json'
 
@@ -8,8 +10,8 @@ module Aspera
       # FASP event listener display management events as JSON
       class LineDump < Fasp::Listener
         def event_enhanced(data)
-          STDOUT.puts(JSON.generate(data))
-          STDOUT.flush
+          $stdout.puts(JSON.generate(data))
+          $stdout.flush
         end
       end
     end

data/lib/aspera/cli/listener/logger.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'aspera/fasp/listener'
 require 'aspera/log'
 
@@ -8,7 +10,7 @@ module Aspera
       class Logger < Fasp::Listener
         def event_struct(data)
           Log.log.debug(data.to_s)
-          Log.log.error("#{data['Description']}") if data['Type'].eql?('FILEERROR')
+          Log.log.error((data['Description']).to_s) if data['Type'].eql?('FILEERROR')
         end
 
         def event_enhanced(data)

data/lib/aspera/cli/listener/progress.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'aspera/fasp/listener'
 require 'ruby-progressbar'
 
@@ -7,42 +9,39 @@ module Aspera
       # a listener to FASP event that displays a progress bar
       class Progress < Fasp::Listener
         def initialize
-          @progress=nil
-          @cumulative=0
+          super
+          @progress = nil
+          @cumulative = 0
         end
 
-        BYTE_PER_MEGABIT=1024*1024/8
+        BYTE_PER_MEGABIT = (1024 * 1024) / 8
 
         def event_struct(data)
           case data['Type']
           when 'NOTIFICATION'
-            if data.has_key?('PreTransferBytes') then
-              @progress=ProgressBar.create(
-              :format     => '%a %B %p%% %r Mbps %e',
-              :rate_scale => lambda{|rate|rate/BYTE_PER_MEGABIT},
-              :title      => 'progress',
-              :total      => data['PreTransferBytes'].to_i)
+            if data.has_key?('PreTransferBytes')
+              @progress = ProgressBar.create(
+                format:      '%a %B %p%% %r Mbps %e',
+                rate_scale:  lambda{|rate|rate / BYTE_PER_MEGABIT},
+                title:       'progress',
+                total:       data['PreTransferBytes'].to_i)
             end
           when 'STOP'
             # stop event when one file is completed
-            @cumulative=@cumulative+data['Size'].to_i
+            @cumulative += data['Size'].to_i
           when 'STATS'
-            if !@progress.nil? then
-              if data.has_key?('Bytescont')
-                @progress.progress=@cumulative+data['Bytescont'].to_i
-              else
-                @progress.progress=data['TransferBytes'].to_i
-              end
-            else
+            if @progress.nil?
               puts '.'
+            else
+              @progress.progress = data.has_key?('Bytescont') ? @cumulative + data['Bytescont'].to_i : data['TransferBytes'].to_i
             end
           when 'DONE'
-            if !@progress.nil? then
-              @progress.progress=@progress.total
-              @progress=nil
-            else
+            if @progress.nil?
               # terminate progress by going to next line
               puts "\n"
+            else
+              @progress.progress = @progress.total
+              @progress = nil
             end
           end
         end

data/lib/aspera/cli/listener/progress_multi.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'aspera/fasp/listener'
 require 'aspera/fasp/agent_base'
 require 'ruby-progressbar'
@@ -8,75 +10,71 @@ module Aspera
       # a listener to FASP event that displays a progress bar
       class ProgressMulti < Fasp::Listener
         def initialize
-          @progress_bar=nil
-          @sessions={}
+          super
+          @progress_bar = nil
+          @sessions = {}
         end
 
         def reset
-          @progress_bar=nil
-          @sessions={}
+          @progress_bar = nil
+          @sessions = {}
         end
 
-        BYTE_PER_MEGABIT=1024*1024/8
+        BYTE_PER_MEGABIT = 1024 * 1024 / 8
 
         def update_total
           begin
-            @progress_bar.total=@sessions.values.inject(0){|m,s|m+=s[:job_size].to_i;m;}
-          rescue
+            @progress_bar.total = @sessions.values.inject(0){|m,s|m += s[:job_size].to_i;m;}
+          rescue StandardError
             nil
           end
         end
 
         def update_progress
           begin
-            @progress_bar.progress=@sessions.values.inject(0){|m,s|m+=s[:current].to_i;m;}
-          rescue
+            @progress_bar.progress = @sessions.values.inject(0){|m,s|m += s[:current].to_i;m;}
+          rescue StandardError
             nil
           end
         end
 
         def event_enhanced(data)
           if @progress_bar.nil?
-            @progress_bar=ProgressBar.create(
-            :format     => '%t %a %B %p%% %r Mbps %e',
-            :rate_scale => lambda{|rate|rate/BYTE_PER_MEGABIT},
-            :title      => '',
-            :total      => nil)
+            @progress_bar = ProgressBar.create(
+              format:      '%t %a %B %p%% %r Mbps %e',
+              rate_scale:  lambda{|rate|rate / BYTE_PER_MEGABIT},
+              title:       '',
+              total:       nil)
           end
           if !data.has_key?(Fasp::AgentBase::LISTENER_SESSION_ID_S)
             Log.log.error("Internal error: no #{Fasp::AgentBase::LISTENER_SESSION_ID_S} in event: #{data}")
             return
           end
-          newtitle=@sessions.length < 2 ? '' : "multi=#{@sessions.length}"
-          @progress_bar.title=newtitle unless @progress_bar.title.eql?(newtitle)
-          session=@sessions[data[Fasp::AgentBase::LISTENER_SESSION_ID_S]]||={
+          newtitle = @sessions.length < 2 ? '' : "multi=#{@sessions.length}"
+          @progress_bar.title = newtitle unless @progress_bar.title.eql?(newtitle)
+          session = @sessions[data[Fasp::AgentBase::LISTENER_SESSION_ID_S]] ||= {
             cumulative: 0,
-            job_size: 0,
-            current: 0
+            job_size:   0,
+            current:    0
           }
           case data['type']
           when 'INIT' # connection to ascp (get id)
           when 'SESSION' # session information
           when 'NOTIFICATION' # sent from remote
-            if data.has_key?('pre_transfer_bytes') then
-              session[:job_size]=data['pre_transfer_bytes']
+            if data.has_key?('pre_transfer_bytes')
+              session[:job_size] = data['pre_transfer_bytes']
               update_total
             end
           when 'STATS' # during transfer
-            if !@progress_bar.total.nil? then
-              if data.has_key?('bytescont')
-                session[:current]=session[:cumulative]+data['bytescont'].to_i
-                update_progress
-              else
-                session[:current]=data['transfer_bytes'].to_i
-                update_progress
-              end
-            else
+            if @progress_bar.total.nil?
               @progress_bar.increment
+            else
+              session[:current] = data.has_key?('bytescont') ? session[:cumulative] + data['bytescont'].to_i : data['transfer_bytes'].to_i
+              update_progress
             end
           when 'STOP'
             # stop event when one file is completed
-            session[:cumulative]=session[:cumulative]+data['size'].to_i
+            session[:cumulative] = session[:cumulative] + data['size'].to_i
           when 'DONE' # end of session
             @sessions.delete(data[Fasp::AgentBase::LISTENER_SESSION_ID_S])
             update_progress