aspera-cli 4.0.0.pre2 → 4.0.0.pre3

data/lib/aspera/cli/manager.rb

@@ -2,6 +2,7 @@ require 'aspera/colors'
 require 'aspera/log'
 require 'aspera/cli/extended_value'
 require 'optparse'
+require 'io/console'
 
 module Aspera
   module Cli
@@ -135,6 +136,12 @@ module Aspera
         Log.log.debug("add_cmd_line_options:commands/args=#{@unprocessed_cmd_line_arguments},options=#{@unprocessed_cmd_line_options}".red)
       end
 
+      def prompt_user_input(prompt,sensitive)
+        return STDIN.getpass("#{prompt}> ") if sensitive
+        print "#{prompt}> "
+        return STDIN.gets.chomp
+      end
+
       def get_interactive(type,descr,expected=:single)
         if !@ask_missing_mandatory
           if expected.is_a?(Array)
@@ -143,23 +150,23 @@ module Aspera
           raise CliBadArgument,"missing argument (#{expected}): #{descr}"
         end
         result=nil
+        # Note: mandatory parenthesis here !
+        sensitive = (type.eql?(:option) and @declared_options[descr.to_sym][:sensitive].eql?(true))
+        default_prompt="#{type}: #{descr}"
         # ask interactively
         case expected
         when :multiple
           result=[]
           puts " (one per line, end with empty line)"
           loop do
-            print "#{type}: #{descr}> "
-            entry=STDIN.gets.chomp
+            entry=prompt_user_input(default_prompt,sensitive)
             break if entry.empty?
             result.push(ExtendedValue.instance.evaluate(entry))
           end
         when :single
-          print "#{type}: #{descr}> "
-          result=ExtendedValue.instance.evaluate(STDIN.gets.chomp)
+          result=ExtendedValue.instance.evaluate(prompt_user_input(default_prompt,sensitive))
         else # one fixed
-          print "#{expected.join(' ')}\n#{type}: #{descr}> "
-          result=self.class.get_from_list(STDIN.gets.chomp,descr,expected)
+          result=self.class.get_from_list(prompt_user_input("#{expected.join(' ')}\n#{default_prompt}",sensitive),descr,expected)
         end
         return result
       end
@@ -206,6 +213,12 @@ module Aspera
           return
         end
         @declared_options[option_symbol]={:type=>type}
+        # by default passwords and secrets are sensitive, else specify when declaring the option
+        set_is_sensitive(option_symbol) if !%w{password secret key}.select{|i| option_symbol.to_s.end_with?(i)}.empty?
+      end
+
+      def set_is_sensitive(option_symbol)
+        @declared_options[option_symbol][:sensitive]=true
       end
 
       # define option with handler

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

@@ -11,7 +11,7 @@ require 'date'
 module Aspera
   module Cli
     module Plugins
-      class Oncloud < BasicAuthPlugin
+      class Aoc < BasicAuthPlugin
         VAL_ALL='ALL'
         private_constant :VAL_ALL
         attr_reader :api_aoc

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

@@ -32,10 +32,8 @@ module Aspera
         PROGRAM_NAME_V2 = 'mlia'
         # default redirect for AoC web auth
         DEFAULT_REDIRECT='http://localhost:12345'
-        # folder containing custom plugins in `main_folder`
+        # folder containing custom plugins in user's config folder
         ASPERA_PLUGINS_FOLDERNAME='plugins'
-        # folder containing plugins in the gem's main folder
-        GEM_PLUGINS_FOLDER='aspera/cli/plugins'
         RUBY_FILE_EXT='.rb'
         AOC_COMMAND_V1='files'
         AOC_COMMAND_V2='aspera'
@@ -50,7 +48,7 @@ module Aspera
           self.options.add_option_preset(preset_by_name(value))
         end
 
-        private_constant :ASPERA_HOME_FOLDER_NAME,:DEFAULT_CONFIG_FILENAME,:CONF_PRESET_CONFIG,:CONF_PRESET_VERSION,:CONF_PRESET_DEFAULT,:PROGRAM_NAME_V1,:PROGRAM_NAME_V2,:DEFAULT_REDIRECT,:ASPERA_PLUGINS_FOLDERNAME,:GEM_PLUGINS_FOLDER,:RUBY_FILE_EXT,:AOC_COMMAND_V1,:AOC_COMMAND_V2,:AOC_COMMAND_V3,:AOC_COMMAND_CURRENT,:DEMO
+        private_constant :ASPERA_HOME_FOLDER_NAME,:DEFAULT_CONFIG_FILENAME,:CONF_PRESET_CONFIG,:CONF_PRESET_VERSION,:CONF_PRESET_DEFAULT,:PROGRAM_NAME_V1,:PROGRAM_NAME_V2,:DEFAULT_REDIRECT,:ASPERA_PLUGINS_FOLDERNAME,:RUBY_FILE_EXT,:AOC_COMMAND_V1,:AOC_COMMAND_V2,:AOC_COMMAND_V3,:AOC_COMMAND_CURRENT,:DEMO
         attr_accessor :option_ak_secret,:option_secrets
 
         def initialize(env,tool_name,help_url,version)
@@ -61,18 +59,25 @@ module Aspera
           @plugin_lookup_folders=[]
           @use_plugin_defaults=true
           @config_presets=nil
+          @connect_versions=nil
           @program_version=version
           @tool_name=tool_name
           @help_url=help_url
-          @main_folder=File.join(Dir.home,ASPERA_HOME_FOLDER_NAME,tool_name)
+          tool_main_env_var="#{tool_name.upcase}_HOME"
+          if ENV.has_key?(tool_main_env_var)
+            @main_folder=ENV[tool_main_env_var]
+          else
+            user_home_folder=Dir.home
+            raise CliError,"Home folder does not exist: #{user_home_folder}. Check your user environment or use #{tool_main_env_var}." unless Dir.exist?(user_home_folder)
+            @main_folder=File.join(user_home_folder,ASPERA_HOME_FOLDER_NAME,tool_name)
+          end
           @conf_file_default=File.join(@main_folder,DEFAULT_CONFIG_FILENAME)
           @option_config_file=@conf_file_default
-          @connect_versions=nil
-          # set folder where generated FASP files are
+          Log.log.debug("#{tool_name} folder: #{@main_folder}")
+          # set folder for FASP SDK
           Fasp::Installation.instance.folder=File.join(@main_folder,'sdk')
-          FileUtils.mkdir_p(Fasp::Installation.instance.folder)
           add_plugin_lookup_folder(File.join(@main_folder,ASPERA_PLUGINS_FOLDERNAME))
-          add_plugin_lookup_folder(File.join(Main.gem_root,GEM_PLUGINS_FOLDER))
+          add_plugin_lookup_folder(self.class.gem_plugins_folder)
           # do file parameter first
           self.options.set_obj_attr(:config_file,self,:option_config_file)
           self.options.add_opt_simple(:config_file,"read parameters from file in YAML format, current=#{@option_config_file}")
@@ -154,6 +159,24 @@ module Aspera
           nil
         end
 
+        # folder containing plugins in the gem's main folder
+        def self.gem_plugins_folder
+          File.dirname(File.expand_path(__FILE__))
+        end
+
+        # find the root folder of gem where this class is
+        # go up as many times as englobing modules (not counting class, as it is a file)
+        def self.gem_root
+          File.expand_path(Module.nesting[1].to_s.gsub('::','/').gsub(%r([^/]+),'..'),File.dirname(__FILE__))
+        end
+
+        # instanciate a plugin
+        # plugins must be Capitalized
+        def self.plugin_new(plugin_name_sym,env)
+          # Module.nesting[2] is Aspera::Cli
+          return Object::const_get("#{Module.nesting[2].to_s}::Plugins::#{plugin_name_sym.to_s.capitalize}").new(env)
+        end
+
         def self.flatten_all_config(t)
           r=[]
           t.each do |k,v|
@@ -219,7 +242,7 @@ module Aspera
         end
 
         def option_ascp_path
-          Fasp::Installation.instance.ascp_path
+          Fasp::Installation.instance.path(:ascp)
         end
 
         def option_use_product=(value)
@@ -450,7 +473,7 @@ module Aspera
             when :use
               default_product=self.options.get_next_argument('product name')
               Fasp::Installation.instance.use_ascp_from_product(default_product)
-              preset_name=set_global_default(:ascp_path,Fasp::Installation.instance.ascp_path)
+              preset_name=set_global_default(:ascp_path,Fasp::Installation.instance.path(:ascp))
               save_presets_to_config_file
               return {:type=>:status, :data=>"saved to default global preset #{preset_name}"}
             end
@@ -578,7 +601,7 @@ module Aspera
               # init defaults if necessary
               @config_presets[CONF_PRESET_DEFAULT]||=Hash.new
               if !option_override
-                raise CliError,"a default configuration already exists for plugin '#{AOC_COMMAND_V2}' (use --override=yes)" if @config_presets[CONF_PRESET_DEFAULT].has_key?(AOC_COMMAND_V2)
+                raise CliError,"a default configuration already exists for plugin '#{AOC_COMMAND_CURRENT}' (use --override=yes)" if @config_presets[CONF_PRESET_DEFAULT].has_key?(AOC_COMMAND_CURRENT)
                 raise CliError,"preset already exists: #{aspera_preset_name}  (use --override=yes)" if @config_presets.has_key?(aspera_preset_name)
               end
               # lets see if path to priv key is provided
@@ -605,11 +628,11 @@ module Aspera
               require 'aspera/cli/plugins/aoc'
               # make username mandatory for jwt, this triggers interactive input
               self.options.get_option(:username,:mandatory)
-              files_plugin=Plugins::Oncloud.new(@agents.merge({skip_basic_auth_options: true, private_key_path: private_key_path}))
+              # instanciate AoC plugin
+              files_plugin=self.class.plugin_new(AOC_COMMAND_CURRENT,@agents.merge({skip_basic_auth_options: true, private_key_path: private_key_path}))
               auto_set_pub_key=false
               auto_set_jwt=false
               use_browser_authentication=false
-
               if self.options.get_option(:use_generic_client)
                 self.format.display_status("Using global client_id.")
                 self.format.display_status("Please Login to your Aspera on Cloud instance.".red)
@@ -669,8 +692,8 @@ module Aspera
                 o=self.options.get_option(s)
                 @config_presets[s.to_s] = o unless o.nil?
               end
-              self.format.display_status("Setting config preset as default for #{AOC_COMMAND_V2}")
-              @config_presets[CONF_PRESET_DEFAULT][AOC_COMMAND_V2]=aspera_preset_name
+              self.format.display_status("Setting config preset as default for #{AOC_COMMAND_CURRENT}")
+              @config_presets[CONF_PRESET_DEFAULT][AOC_COMMAND_CURRENT]=aspera_preset_name
               self.format.display_status("saving config file")
               save_presets_to_config_file
               return Main.result_status("Done.\nYou can test with:\n#{@tool_name} #{AOC_COMMAND_CURRENT} user info show")
@@ -682,7 +705,8 @@ module Aspera
             require 'aspera/cli/plugins/aoc'
             # need url / username
             add_plugin_default_preset(AOC_COMMAND_V3.to_sym)
-            files_plugin=Plugins::Oncloud.new(@agents) # TODO: is this line needed ?
+            # instanciate AoC plugin
+            files_plugin=self.class.plugin_new(AOC_COMMAND_CURRENT,@agents) # TODO: is this line needed ?
             url=self.options.get_option(:url,:mandatory)
             cli_conf_file=Fasp::Installation.instance.cli_conf_file
             data=JSON.parse(File.read(cli_conf_file))
@@ -721,7 +745,7 @@ module Aspera
           when :ascp
             execute_action_ascp
           when :gem_path
-            return Main.result_status(Main.gem_root)
+            return Main.result_status(self.class.gem_root)
           when :folder
             return Main.result_status(@main_folder)
           when :file

data/lib/aspera/cli/version.rb

@@ -1,5 +1,5 @@
 module Aspera
   module Cli
-    VERSION = "4.0.0.pre2"
+    VERSION = "4.0.0.pre3"
   end
 end

data/lib/aspera/colors.rb

@@ -33,7 +33,11 @@ class String
   VTSTYLES.each do |name,code|
     begin_seq=vtcmd(code)
     end_seq=vtcmd((code >= 10) ? 0 : code+20+(code.eql?(1)?1:0))
-    define_method(name){"#{begin_seq}#{self}#{end_seq}"}
+    if STDERR.tty?
+      define_method(name){"#{begin_seq}#{self}#{end_seq}"}
+    else
+      define_method(name){self}
+    end
     public name
   end
 end

data/lib/aspera/environment.rb

@@ -1,4 +1,5 @@
 require 'aspera/log'
+require 'rbconfig'
 
 module Aspera
   # a simple binary data repository
@@ -20,7 +21,7 @@ module Aspera
       when /aix/
         return OS_AIX
       else
-        raise "Unknown: #{RbConfig::CONFIG['host_os']}"
+        raise "Unknown OS: #{RbConfig::CONFIG['host_os']}"
       end
     end
     CPU_X86_64=:x86_64
@@ -31,7 +32,7 @@ module Aspera
 
     def self.cpu
       case RbConfig::CONFIG['host_cpu']
-      when /x86_64/
+      when /x86_64/,/x64/
         return :x86_64
       when /powerpc/
         return :ppc64le if os.eql?(OS_LINUX)
@@ -39,7 +40,7 @@ module Aspera
       when /s390/
         return :s390
       else # other
-        raise "Unknown: #{RbConfig::CONFIG['host_cpu']}"
+        raise "Unknown CPU: #{RbConfig::CONFIG['host_cpu']}"
       end
     end
 
@@ -51,5 +52,15 @@ module Aspera
       return '.exe' if os.eql?(OS_WINDOWS)
       return ''
     end
+
+    # on Windows, the env var %USERPROFILE% provides the path to user's home more reliably then %HOMEDRIVE%%HOMEPATH%
+    def self.fix_home
+      if os.eql?(OS_WINDOWS)
+        if ENV.has_key?('USERPROFILE') and Dir.exist?(ENV['USERPROFILE'])
+          ENV['HOME']=ENV['USERPROFILE']
+          Log.log.debug("Windows: set home to USERPROFILE: #{ENV['HOME']}")
+        end
+      end
+    end
   end
 end

data/lib/aspera/fasp/installation.rb

@@ -5,6 +5,7 @@ require 'aspera/data_repository'
 require 'xmlsimple'
 require 'zlib'
 require 'base64'
+require 'fileutils'
 
 module Aspera
   module Fasp
@@ -17,14 +18,21 @@ module Aspera
     # Installation.instance.ascp_path=""
     class Installation
       include Singleton
-      # currently used ascp executable
-      attr_accessor :ascp_path
-      # location of SDK files
-      attr_accessor :folder
       PRODUCT_CONNECT='Aspera Connect'
       PRODUCT_CLI_V1='Aspera CLI'
       PRODUCT_DRIVE='Aspera Drive'
       PRODUCT_ENTSRV='Enterprise Server'
+      # currently used ascp executable
+      def ascp_path=(v)
+        @path_to_ascp=v
+      end
+
+      # location of SDK files
+      def folder=(v)
+        @sdk_folder=v
+        folder_path
+      end
+
       # find ascp in named product (use value : FIRST_FOUND='FIRST' to just use first one)
       # or select one from installed_products()
       def use_ascp_from_product(product_name)
@@ -35,8 +43,8 @@ module Aspera
           pl=installed_products.select{|i|i[:name].eql?(product_name)}.first
           raise "no such product installed: #{product_name}" if pl.nil?
         end
-        @ascp_path=pl[:ascp_path]
-        Log.log.debug("ascp_path=#{@ascp_path}")
+        self.ascp_path=pl[:ascp_path]
+        Log.log.debug("ascp_path=#{@path_to_ascp}")
       end
 
       # @return the list of installed products in format of product_locations
@@ -46,7 +54,7 @@ module Aspera
           # add sdk as first search path
           @found_products.unshift({# SDK
             :expected =>'SDK',
-            :app_root =>@folder,
+            :app_root =>self.folder_path,
             :sub_bin =>''
           })
           @found_products.select! do |pl|
@@ -76,24 +84,24 @@ module Aspera
       def path(k)
         case k
         when :ascp,:ascp4
-          use_ascp_from_product(FIRST_FOUND) if @ascp_path.nil?
-          file=@ascp_path
+          use_ascp_from_product(FIRST_FOUND) if @path_to_ascp.nil?
+          file=@path_to_ascp
           # note that there might be a .exe at the end
           file=file.gsub('ascp','ascp4') if k.eql?(:ascp4)
         when :ssh_bypass_key_dsa
-          file=File.join(@folder,'aspera_bypass_dsa.pem')
+          file=File.join(self.folder_path,'aspera_bypass_dsa.pem')
           File.write(file,get_key('dsa',1)) unless File.exist?(file)
           File.chmod(0400,file)
         when :ssh_bypass_key_rsa
-          file=File.join(@folder,'aspera_bypass_rsa.pem')
+          file=File.join(self.folder_path,'aspera_bypass_rsa.pem')
           File.write(file,get_key('rsa',2)) unless File.exist?(file)
           File.chmod(0400,file)
         when :aspera_license
-          file=File.join(@folder,'aspera-license')
+          file=File.join(self.folder_path,'aspera-license')
           File.write(file,Base64.strict_encode64("#{Zlib::Inflate.inflate(DataRepository.instance.get_bin(6))}==SIGNATURE==\n#{Base64.strict_encode64(DataRepository.instance.get_bin(7))}")) unless File.exist?(file)
           File.chmod(0400,file)
         when :aspera_conf
-          file=File.join(@folder,'aspera.conf')
+          file=File.join(self.folder_path,'aspera.conf')
           File.write(file,%Q{<?xml version='1.0' encoding='UTF-8'?>
 <CONF version="2">
 <default>
@@ -112,8 +120,8 @@ module Aspera
 }) unless File.exist?(file)
           File.chmod(0400,file)
         when :fallback_cert,:fallback_key
-          file_key=File.join(@folder,'aspera_fallback_key.pem')
-          file_cert=File.join(@folder,'aspera_fallback_cert.pem')
+          file_key=File.join(self.folder_path,'aspera_fallback_key.pem')
+          file_cert=File.join(self.folder_path,'aspera_fallback_cert.pem')
           if !File.exist?(file_key) or !File.exist?(file_cert)
             require 'openssl'
             # create new self signed certificate for http fallback
@@ -180,7 +188,7 @@ module Aspera
         Zip::File.open(sdk_zip_path) do |zip_file|
           zip_file.each do |entry|
             if entry.name.include?(filter) and !entry.name.end_with?('/')
-              archive_file=File.join(@folder,File.basename(entry.name))
+              archive_file=File.join(self.folder_path,File.basename(entry.name))
               File.open(archive_file, 'wb') do |output_stream|
                 IO.copy_stream(entry.get_input_stream, output_stream)
               end
@@ -197,7 +205,7 @@ module Aspera
           # get version from ascp, only after full extract, as windows requires SSL/TLS DLLs
           m=%x{#{ascp_path} -A}.match(/ascp version (.*)/)
           ascp_version=m[1] unless m.nil?
-          File.write(File.join(@folder,PRODUCT_INFO),"<product><name>IBM Aspera SDK</name><version>#{ascp_version}</version></product>")
+          File.write(File.join(self.folder_path,PRODUCT_INFO),"<product><name>IBM Aspera SDK</name><version>#{ascp_version}</version></product>")
         end
         return ascp_version
       end
@@ -223,11 +231,17 @@ module Aspera
       end
 
       def initialize
-        @ascp_path=nil
-        @folder='.'
+        @path_to_ascp=nil
+        @sdk_folder=nil
         @found_products=nil
       end
 
+      def folder_path
+        raise "undefined path to SDK" if @sdk_folder.nil?
+        FileUtils.mkdir_p(@sdk_folder) unless Dir.exist?(@sdk_folder)
+        @sdk_folder
+      end
+
       # returns product folders depending on OS
       # fields
       # :expected  M app name is taken from the manifest if present, else defaults to this value

data/lib/aspera/fasp/local.rb

@@ -17,17 +17,25 @@ require 'securerandom'
 
 module Aspera
   module Fasp
-    # default transfer username for access key based transfers
+    # (public) default transfer username for access key based transfers
     ACCESS_KEY_TRANSFER_USER='xfer'
     # executes a local "ascp", connects mgt port, equivalent of "Fasp Manager"
     class Local < Manager
+      ASCP_SPAWN_TIMEOUT_SEC = 3
+      private_constant :ASCP_SPAWN_TIMEOUT_SEC
       # set to false to keep ascp progress bar display (basically: removes ascp's option -q)
       attr_accessor :quiet
-      # start FASP transfer based on transfer spec (hash table)
-      # note that it is asynchronous
+      # start ascp transfer (non blocking), single or multi-session
+      # job information added to @jobs
+      # @param transfer_spec [Hash] aspera transfer specification
+      # @param options [Hash] :resumer, :regenerate_token
       def start_transfer(transfer_spec,options={})
         raise "option: must be hash (or nil)" unless options.is_a?(Hash)
-        job_id=options[:job_id] || SecureRandom.uuid
+        job_options = options.clone
+        job_options[:resumer] ||= @resume_policy
+        job_options[:job_id] ||= SecureRandom.uuid
+        # clone transfer spec because we modify it (first level keys)
+        transfer_spec=transfer_spec.clone
         # if there is aspera tags
         if transfer_spec['tags'].is_a?(Hash) and transfer_spec['tags']['aspera'].is_a?(Hash)
           # TODO: what is this for ? only on local ascp ?
@@ -39,6 +47,7 @@ module Aspera
           transfer_spec['tags']['aspera']['xfer_retry']||=3600
         end
         Log.dump('ts',transfer_spec)
+
         # add bypass keys when authentication is token and no auth is provided
         if transfer_spec.has_key?('token') and
         !transfer_spec.has_key?('remote_password') and
@@ -47,6 +56,21 @@ module Aspera
           transfer_spec['EX_ssh_key_paths'] = Installation.instance.bypass_keys
         end
 
+        # TODO: check if changing fasp(UDP) port is really necessary, not clear from doc
+        # compute this before using transfer spec, even if the var is not used in single session
+        multi_session_udp_port_base=33001
+        multi_session_number=nil
+        if transfer_spec.has_key?('multi_session')
+          multi_session_number=transfer_spec['multi_session'].to_i
+          raise "multi_session(#{transfer_spec['multi_session']}) shall be integer > 1" unless multi_session_number >= 1
+          # managed here, so delete from transfer spec
+          transfer_spec.delete('multi_session')
+          if transfer_spec.has_key?('fasp_port')
+            multi_session_udp_port_base=transfer_spec['fasp_port']
+            transfer_spec.delete('fasp_port')
+          end
+        end
+
         # compute known args
         env_args=Parameters.ts_to_env_args(transfer_spec,wss: @enable_wss)
 
@@ -60,41 +84,32 @@ module Aspera
 
         # transfer job can be multi session
         xfer_job={
-          :id            => job_id,
-          :sessions      => []
+          :id            => job_options[:job_id],
+          :sessions      => [] # all sessions as below
         }
 
         # generic session information
         session={
-          :state    => :initial, # :initial, :started, :success, :failed
-          :env_args => env_args,
-          :resumer  => options['resume_policy'] || @resume_policy,
-          :options  => options
+          :thread   => nil,         # Thread object monitoring management port, not nil when pushed to :sessions
+          :error    => nil,         # exception if failed
+          :io       => nil,         # management port server socket
+          :id       => nil,         # SessionId from INIT message in mgt port
+          :env_args => env_args,    # env vars and args to ascp (from transfer spec)
+          :options  => job_options  # [Hash]
         }
 
         Log.log.debug("starting session thread(s)")
-        if !transfer_spec.has_key?('multi_session')
+        if !multi_session_number
           # single session for transfer : simple
           session[:thread] = Thread.new(session) {|s|transfer_thread_entry(s)}
           xfer_job[:sessions].push(session)
         else
-          # default value overriden by fasp_port
-          multi_session_udp_port_base=33001
-          multi_session=transfer_spec['multi_session'].to_i
-          raise "multi_session(#{transfer_spec['multi_session']}) shall be integer > 1" unless multi_session >= 1
-          # managed here, so delete from transfer spec
-          transfer_spec.delete('multi_session')
-          # TODO: check if changing fasp(UDP) port is really necessary, not clear from doc
-          if transfer_spec.has_key?('fasp_port')
-            multi_session_udp_port_base=transfer_spec['fasp_port']
-            transfer_spec.delete('fasp_port')
-          end
-          1.upto(multi_session) do |i|
+          1.upto(multi_session_number) do |i|
             # do deep copy (each thread has its own copy because it is modified here below and in thread)
             this_session=session.clone()
             this_session[:env_args]=this_session[:env_args].clone()
             this_session[:env_args][:args]=this_session[:env_args][:args].clone()
-            this_session[:env_args][:args].unshift("-C#{i}:#{multi_session}")
+            this_session[:env_args][:args].unshift("-C#{i}:#{multi_session_number}")
             # necessary only if server is not linux, i.e. server does not support port re-use
             this_session[:env_args][:args].unshift("-O","#{multi_session_udp_port_base+i-1}")
             this_session[:thread] = Thread.new(this_session) {|s|transfer_thread_entry(s)}
@@ -104,74 +119,59 @@ module Aspera
         Log.log.debug("started session thread(s)")
 
         # add job to list of jobs
-        @jobs[job_id]=xfer_job
-
+        @jobs[job_options[:job_id]]=xfer_job
         Log.log.debug("jobs: #{@jobs.keys.count}")
-        return job_id
+
+        return job_options[:job_id]
       end # start_transfer
 
       # wait for completion of all jobs started
       # @return list of :success or error message
       def wait_for_transfers_completion
-        Log.log.debug("wait_for_sessions: #{@jobs.values.inject(0){|m,j|m+j[:sessions].count}}")
-        @mutex.synchronize do
-          loop do
-            running=0
-            result=[]
-            @jobs.each do |id,job|
-              job[:sessions].each do |session|
-                case session[:state]
-                when :failed; result.push(session[:error])
-                when :success; result.push(:success)
-                else running+=1
-                end
-              end
-            end
-            if running.eql?(0)
-              # since all are finished and we return the result, clear statuses
-              @jobs.clear
-              return result
-            end
-            Log.log.debug("wait for completed: running: #{running}")
-            # wait for session termination
-            @cond_var.wait(@mutex)
-          end # loop
-        end # mutex
-        # never reach here
-        raise "internal error"
+        Log.log.debug("wait_for_transfers_completion")
+        # set to non-nil to exit loop
+        result=[]
+        @jobs.each do |id,job|
+          job[:sessions].each do |session|
+            Log.log.debug("join #{session[:thread]}")
+            session[:thread].join
+            result.push(session[:error] ? session[:error] : :success)
+          end
+        end
+        Log.log.debug("all transfers joined")
+        # since all are finished and we return the result, clear statuses
+        @jobs.clear
+        return result
       end
 
-      # terminates monitor thread
+      # used by asession (to be removed ?)
       def shutdown
         Log.log.debug("fasp local shutdown")
-        Log.log.debug("send signal to monitor")
-        # tell monitor to stop
-        @mutex.synchronize do
-          @monitor_stop=true
-          @cond_var.broadcast
-        end
-        # wait for thread termination
-        @monitor_thread.join
-        @monitor_thread=nil
-        Log.log.debug("joined monitor")
       end
 
-      # This is the low level method to start FASP
+      # This is the low level method to start the "ascp" process
       # currently, relies on command line arguments
       # start ascp with management port.
       # raises FaspError on error
       # if there is a thread info: set and broadcast session id
       # @param env_args a hash containing :args :env :ascp_version
-      # cloud be private method
-      def start_transfer_with_args_env(env_args,session=nil)
+      # @param session this session information
+      # could be private method
+      def start_transfer_with_args_env(env_args,session)
+        raise "env_args must be Hash" unless env_args.is_a?(Hash)
+        raise "session must be Hash" unless session.is_a?(Hash)
         begin
           Log.log.debug("env_args=#{env_args.inspect}")
-          ascp_path=Fasp::Installation.instance.path(env_args[:ascp_version])
+          # get location of ascp executable
+          ascp_path=@mutex.synchronize do
+            Fasp::Installation.instance.path(env_args[:ascp_version])
+          end
+          # (optional) check it exists
           raise Fasp::Error.new("no such file: #{ascp_path}") unless File.exist?(ascp_path)
-          ascp_pid=nil
+          # open random local TCP port for listening for ascp management
+          mgt_sock = TCPServer.new('127.0.0.1',0)
+          # clone arguments as we eed to modify with mgt port
           ascp_arguments=env_args[:args].clone
-          # open random local TCP port listening
-          mgt_sock = TCPServer.new('127.0.0.1',0 )
           # add management port
           ascp_arguments.unshift('-M', mgt_sock.addr[1].to_s)
           # start ascp in sub process
@@ -180,8 +180,9 @@ module Aspera
           ascp_pid = Process.spawn(env_args[:env],[ascp_path,ascp_path],*ascp_arguments)
           # in parent, wait for connection to socket max 3 seconds
           Log.log.debug("before accept for pid (#{ascp_pid})")
+          # init management socket
           ascp_mgt_io=nil
-          Timeout.timeout( 3 ) do
+          Timeout.timeout(ASCP_SPAWN_TIMEOUT_SEC) do
             ascp_mgt_io = mgt_sock.accept
             # management messages include file names which may be utf8
             # by default socket is US-ASCII
@@ -189,21 +190,13 @@ module Aspera
             ascp_mgt_io.set_encoding(Encoding::UTF_8)
           end
           Log.log.debug("after accept (#{ascp_mgt_io})")
-
-          unless session.nil?
-            @mutex.synchronize do
-              session[:io]=ascp_mgt_io
-              @cond_var.broadcast
-            end
-          end
+          session[:io]=ascp_mgt_io
           # exact text for event, with \n
           current_event_text=''
           # parsed event (hash)
           current_event_data=nil
-
           # this is the last full status
           last_status_event=nil
-
           # read management port
           loop do
             # TODO: timeout here ?
@@ -222,45 +215,40 @@ module Aspera
               # event field
               current_event_data[$1] = $2
             when ''
-              # end event
+              # empty line is separator to end event information
               raise "unexpected empty line" if current_event_data.nil?
               current_event_data[Manager::LISTENER_SESSION_ID_B]=ascp_pid
               notify_listeners(current_event_text,current_event_data)
-              # TODO: check if this is always the last event
               case current_event_data['Type']
+              when 'INIT'
+                session[:id]=current_event_data['SessionId']
+                Log.log.debug("session id: #{session[:id]}")
               when 'DONE','ERROR'
+                # TODO: check if this is always the last event
                 last_status_event = current_event_data
-              when 'INIT'
-                unless session.nil?
-                  @mutex.synchronize do
-                    session[:state]=:started
-                    session[:id]=current_event_data['SessionId']
-                    Log.log.debug("session id: #{session[:id]}")
-                    @cond_var.broadcast
-                  end
-                end
               end # event type
             else
               raise "unexpected line:[#{line}]"
             end # case
-          end # loop
+          end # loop (process mgt port lines)
           # check that last status was received before process exit
           raise "INTERNAL: nil last status" if last_status_event.nil?
           case last_status_event['Type']
           when 'DONE'
+            # return method (or just don't do anything)
             return
           when 'ERROR'
             Log.log.error("code: #{last_status_event['Code']}")
             if last_status_event['Description']  =~ /bearer token/i
               Log.log.error("need to regenerate token".red)
-              if !session.nil? and session[:options].is_a?(Hash) and session[:options].has_key?(:regenerate_token)
+              if session[:options].is_a?(Hash) and session[:options].has_key?(:regenerate_token)
                 # regenerate token here, expired, or error on it
                 env_args[:env]['ASPERA_SCP_TOKEN']=session[:options][:regenerate_token].call(true)
               end
             end
             raise Fasp::Error.new(last_status_event['Description'],last_status_event['Code'].to_i)
           else
-            raise "INTERNAL ERROR: unexpected last event"
+            raise "unexpected last event type: #{last_status_event['Type']}"
           end
         rescue SystemCallError => e
           # Process.spawn
@@ -270,13 +258,9 @@ module Aspera
         rescue Interrupt => e
           raise Fasp::Error.new('transfer interrupted by user')
         ensure
-          # ensure there is no ascp left running
+          # if ascp was successfully started
           unless ascp_pid.nil?
-            begin
-              Process.kill('INT',ascp_pid)
-            rescue
-            end
-            # avoid zombie
+            # "wait" for process to avoid zombie
             Process.wait(ascp_pid)
             ascp_pid=nil
             session.delete(:io)
@@ -284,24 +268,26 @@ module Aspera
         end # begin-ensure
       end # start_transfer_with_args_env
 
-      # send command on mgt port, examples:
+      # send command of management port to ascp session
+      # @param job_id identified transfer process
+      # @param session_index index of session (for multi session)
+      # @param data command on mgt port, examples:
       # {'type'=>'START','source'=>_path_,'destination'=>_path_}
       # {'type'=>'DONE'}
       def send_command(job_id,session_index,data)
-        @mutex.synchronize do
-          job=@jobs[job_id]
-          raise "no such job" if job.nil?
-          session=job[:sessions][session_index]
-          raise "no such session" if session.nil?
-          Log.log.debug("command: #{data}")
-          command=data.
-          keys.
-          map{|k|"#{k.capitalize}: #{data[k]}"}.
-          unshift('FASPMGR 2').
-          push('','').
-          join("\n")
-          session[:io].puts(command)
-        end
+        job=@jobs[job_id]
+        raise "no such job" if job.nil?
+        session=job[:sessions][session_index]
+        raise "no such session" if session.nil?
+        Log.log.debug("command: #{data}")
+        # build command
+        command=data.
+        keys.
+        map{|k|"#{k.capitalize}: #{data[k]}"}.
+        unshift('FASPMGR 2').
+        push('','').
+        join("\n")
+        session[:io].puts(command)
       end
 
       private
@@ -311,66 +297,33 @@ module Aspera
         super()
         # by default no interactive progress bar
         @quiet=true
-        # shared data between transfer threads and others: protected by mutex, CV on change
+        # all transfer jobs, key = SecureRandom.uuid, protected by mutex, condvar on change
         @jobs={}
-        # mutex protects jobs data
+        # mutex protects global data accessed by threads
         @mutex=Mutex.new
-        # cond var is waited or broadcast on jobs data change
-        @cond_var=ConditionVariable.new
-        # must be set before starting monitor, set to false to stop thread. also shared and protected by mutex
-        @monitor_stop=false
-        @monitor_thread=Thread.new{monitor_thread_entry}
         @resume_policy=ResumePolicy.new(agent_options)
         @enable_wss = agent_options[:wss] || false
       end
 
       # transfer thread entry
-      # implements resumable transfer
-      # TODO: extract resume algorithm in a specific object
+      # @param session information
       def transfer_thread_entry(session)
         begin
           # set name for logging
           Thread.current[:name]="transfer"
-          # update state once in thread
-          session[:state]=:started
           Log.log.debug("ENTER (#{Thread.current[:name]})")
           # start transfer with selected resumer policy
-          session[:resumer].process do
+          session[:options][:resumer].process do
             start_transfer_with_args_env(session[:env_args],session)
           end
           Log.log.debug('transfer ok'.bg_green)
-          session[:state]=:success
         rescue => e
-          session[:state]=:failed
           session[:error]=e
-          Log.log.error("#{e.class}:\n#{e.message}:\n#{e.backtrace.join("\n")}".red) if Log.instance.level.eql?(:debug)
-        ensure
-          @mutex.synchronize do
-            # ensure id is set to unblock start procedure
-            session[:id]||=nil
-            @cond_var.broadcast
-          end
+          Log.log.error("Transfer thread error: #{e.class}:\n#{e.message}:\n#{e.backtrace.join("\n")}".red) if Log.instance.level.eql?(:debug)
         end
         Log.log.debug("EXIT (#{Thread.current[:name]})")
       end
 
-      # main thread method for monitor
-      # currently: just joins started threads
-      def monitor_thread_entry
-        Thread.current[:name]="monitor"
-        @mutex.synchronize do
-          until @monitor_stop do
-            # wait for session termination
-            @cond_var.wait(@mutex)
-            @jobs.values do |job|
-              job[:sessions].each do |session|
-                session[:thread].join if [:success,:failed].include?(session[:state])
-              end # sessions
-            end # jobs
-          end # monitor run
-        end # sync
-        Log.log.debug("EXIT (#{Thread.current[:name]})")
-      end # monitor_thread_entry
     end # Local
   end
 end