aspera-cli 4.24.1 → 4.25.0.pre

data/lib/aspera/cli/wizard.rb

@@ -1,9 +1,12 @@
 # frozen_string_literal: true
 
 require 'aspera/oauth/jwt'
+require 'aspera/assert'
+require 'aspera/cli/plugins/factory'
 
 module Aspera
   module Cli
+    # The wizard detects applications and generates a config
     class Wizard
       WIZARD_RESULT_KEYS = %i[preset_value test_args].freeze
       DEFAULT_PRIV_KEY_FILENAME = 'my_private_key.pem' # pragma: allowlist secret
@@ -13,13 +16,17 @@ module Aspera
       def initialize(parent, main_folder)
         @parent = parent
         @main_folder = main_folder
-        # wizard options
-        options.declare(:override, 'Wizard: override existing value', values: :bool, default: :no)
-        options.declare(:default, 'Wizard: set as default configuration for specified plugin (also: update)', values: :bool, default: true)
-        options.declare(:test_mode, 'Wizard: skip private key check step', values: :bool, default: false)
+        # Wizard options
+        options.declare(:override, 'Wizard: override existing value', allowed: Allowed::TYPES_BOOLEAN, default: false)
+        options.declare(:default, 'Wizard: set as default configuration for specified plugin (also: update)', allowed: Allowed::TYPES_BOOLEAN, default: true)
         options.declare(:key_path, 'Wizard: path to private key for JWT')
       end
 
+      # @return false if in test mode to avoid interactive input
+      def required
+        !ENV['ASCLI_WIZ_TEST']
+      end
+
       def options
         @parent.options
       end
@@ -32,6 +39,10 @@ module Aspera
         @parent.config
       end
 
+      def check_email(email)
+        Aspera.assert(email =~ /\A[\w+\-.]+@[a-z\d\-.]+\.[a-z]+\z/i, type: ParameterError){"Username shall be an email: #{email}"}
+      end
+
       # Find a plugin, and issue the "require"
       # @return [Hash] plugin info: { product:, name:, url:, version: }
       def identify_plugins_for_url
@@ -40,19 +51,19 @@ module Aspera
         check_only = check_only.to_sym unless check_only.nil?
         found_apps = []
         my_self_plugin_sym = self.class.name.split('::').last.downcase.to_sym
-        PluginFactory.instance.plugin_list.each do |plugin_name_sym|
-          # no detection for internal plugin
+        Plugins::Factory.instance.plugin_list.each do |plugin_name_sym|
+          # No detection for internal plugin
           next if plugin_name_sym.eql?(my_self_plugin_sym)
           next if check_only && !check_only.eql?(plugin_name_sym)
-          # load plugin class
-          detect_plugin_class = PluginFactory.instance.plugin_class(plugin_name_sym)
-          # requires detection method
-          next unless detect_plugin_class.respond_to?(:detect)
+          # Load plugin class
+          plugin_klass = Plugins::Factory.instance.plugin_class(plugin_name_sym)
+          # Requires detection method
+          next unless plugin_klass.respond_to?(:detect)
           detection_info = nil
           begin
             Log.log.debug{"detecting #{plugin_name_sym} at #{app_url}"}
             formatter.long_operation_running("#{plugin_name_sym}\r")
-            detection_info = detect_plugin_class.detect(app_url)
+            detection_info = plugin_klass.detect(app_url)
           rescue OpenSSL::SSL::SSLError => e
             Log.log.warn(e.message)
             Log.log.warn('Use option --insecure=yes to allow unchecked certificate') if e.message.include?('cert')
@@ -63,8 +74,8 @@ module Aspera
           next if detection_info.nil?
           Aspera.assert_type(detection_info, Hash)
           Aspera.assert_type(detection_info[:url], String) if detection_info.key?(:url)
-          app_name = detect_plugin_class.respond_to?(:application_name) ? detect_plugin_class.application_name : detect_plugin_class.name.split('::').last
-          # if there is a redirect, then the detector can override the url.
+          app_name = plugin_klass.respond_to?(:application_name) ? plugin_klass.application_name : plugin_klass.name.split('::').last
+          # If there is a redirect, then the detector can override the url.
           found_apps.push({product: plugin_name_sym, name: app_name, url: app_url, version: 'unknown'}.merge(detection_info))
         end
         raise "No known application found at #{app_url}" if found_apps.empty?
@@ -72,6 +83,42 @@ module Aspera
         return found_apps
       end
 
+      # To be called in public wizard method to get private key
+      # @param user [String] User's email
+      # @param url  [String] Instance URL
+      # @param page [String] URL of page to enter pub key
+      # @return [String] Private key path (can contain ~ for home)
+      def ask_private_key(user:, url:, page:)
+        # Lets see if path to priv key is provided
+        private_key_path = options.get_option(:key_path)
+        # Give a chance to provide
+        if private_key_path.nil?
+          formatter.display_status('Path to private RSA key (leave empty to generate):')
+          private_key_path = options.get_option(:key_path, mandatory: true).to_s
+        end
+        # Else generate path
+        private_key_path = File.join(@main_folder, DEFAULT_PRIV_KEY_FILENAME) if private_key_path.empty?
+        if File.exist?(File.expand_path(private_key_path))
+          formatter.display_status('Using existing key:')
+        else
+          formatter.display_status("Generating #{OAuth::Jwt::DEFAULT_PRIV_KEY_LENGTH} bit RSA key...")
+          OAuth::Jwt.generate_rsa_private_key(path: private_key_path)
+          formatter.display_status('Created key:')
+        end
+        formatter.display_status(private_key_path)
+        private_key_pem = File.read(File.expand_path(private_key_path))
+        pub_key_pem = OpenSSL::PKey::RSA.new(private_key_pem).public_key.to_s
+        options.set_option(:private_key, private_key_pem)
+        formatter.display_status("Please Log in as user #{user.red} at: #{url.red}")
+        formatter.display_status("Navigate to: #{page}")
+        formatter.display_status("Check or update the value to (#{'including BEGIN/END lines'.red}):".blink)
+        formatter.display_status(pub_key_pem, hide_secrets: false)
+        formatter.display_status('Once updated or validated, press [Enter].')
+        Environment.instance.open_uri(url)
+        $stdin.gets if required
+        private_key_path
+      end
+
       # Wizard function, creates configuration
       # @param apps [Array] list of detected apps
       def find(apps)
@@ -88,49 +135,18 @@ module Aspera
         Log.dump(:identification, identification)
         wiz_url = identification[:url]
         formatter.display_status("Using: #{identification[:name]} at #{wiz_url}".bold)
-        # set url for instantiation of plugin
+        # Set url for instantiation of plugin
         options.add_option_preset({url: wiz_url}, 'wizard')
-        # instantiate plugin: command line options will be known and wizard can be called
-        wiz_plugin_class = PluginFactory.instance.plugin_class(identification[:product])
-        Aspera.assert(wiz_plugin_class.respond_to?(:wizard), type: Cli::BadArgument) do
+        # Instantiate plugin: command line options will be known, e.g. private_key, and wizard can be called
+        plugin_instance = Plugins::Factory.instance.plugin_class(identification[:product]).new(context: @parent.context)
+        Aspera.assert(plugin_instance.respond_to?(:wizard), type: Cli::BadArgument) do
           "Detected: #{identification[:product]}, but this application has no wizard"
         end
-        # instantiate plugin: command line options will be known, e.g. private_key
-        plugin_instance = wiz_plugin_class.new(context: @parent.context)
-        wiz_params = {
-          object: plugin_instance
-        }
-        # is private key needed ?
-        if options.known_options.key?(:private_key) &&
-            (!wiz_plugin_class.respond_to?(:private_key_required?) || wiz_plugin_class.private_key_required?(wiz_url))
-          # lets see if path to priv key is provided
-          private_key_path = options.get_option(:key_path)
-          # give a chance to provide
-          if private_key_path.nil?
-            formatter.display_status('Path to private RSA key (leave empty to generate):')
-            private_key_path = options.get_option(:key_path, mandatory: true).to_s
-          end
-          # else generate path
-          private_key_path = File.join(@main_folder, DEFAULT_PRIV_KEY_FILENAME) if private_key_path.empty?
-          if File.exist?(private_key_path)
-            formatter.display_status('Using existing key:')
-          else
-            formatter.display_status("Generating #{OAuth::Jwt::DEFAULT_PRIV_KEY_LENGTH} bit RSA key...")
-            OAuth::Jwt.generate_rsa_private_key(path: private_key_path)
-            formatter.display_status('Created key:')
-          end
-          formatter.display_status(private_key_path)
-          private_key_pem = File.read(private_key_path)
-          options.set_option(:private_key, private_key_pem)
-          wiz_params[:private_key_path] = private_key_path
-          wiz_params[:pub_key_pem] = OpenSSL::PKey::RSA.new(private_key_pem).public_key.to_s
-        end
-        Log.dump(:wiz_params, wiz_params)
-        # finally, call the wizard
-        wizard_result = wiz_plugin_class.wizard(**wiz_params)
+        # Call the wizard
+        wizard_result = plugin_instance.wizard(self, wiz_url)
         Log.log.debug{"wizard result: #{wizard_result}"}
         Aspera.assert(WIZARD_RESULT_KEYS.eql?(wizard_result.keys.sort)){"missing or extra keys in wizard result: #{wizard_result.keys}"}
-        # get preset name from user or default
+        # Get preset name from user or default
         if wiz_preset_name.empty?
           elements = [
             identification[:product],
@@ -139,18 +155,17 @@ module Aspera
           elements.push(options.get_option(:username, mandatory: true)) unless wizard_result[:preset_value].key?(:link) rescue nil
           wiz_preset_name = elements.join('_').strip.downcase.gsub(/[^a-z0-9]/, '_').squeeze('_')
         end
-        # test mode does not change conf file
-        return Main.result_single_object(wizard_result) if options.get_option(:test_mode)
         # Write configuration file
         formatter.display_status("Preparing preset: #{wiz_preset_name}")
-        # init defaults if necessary
+        # Init defaults if necessary
         option_override = options.get_option(:override, mandatory: true)
         option_default = options.get_option(:default, mandatory: true)
         config.defaults_set(identification[:product], wiz_preset_name, wizard_result[:preset_value].stringify_keys, option_default, option_override)
         test_args = wizard_result[:test_args]
         test_args = "-P#{wiz_preset_name} #{test_args}" unless option_default
         # TODO: actually test the command
-        return Main.result_status("You can test with:\n#{Info::CMD_NAME} #{identification[:product]} #{test_args}")
+        test_cmd = "#{Info::CMD_NAME} #{identification[:product]} #{test_args}"
+        return Main.result_status("You can test with:\n#{test_cmd.red}")
       end
     end
   end

data/lib/aspera/colors.rb

@@ -57,10 +57,16 @@ class String
       define_method(name){self}
     end
   end
+
   # Transform capitalized to snake case
   def capital_to_snake
     return gsub(/([a-z\d])([A-Z])/, '\1_\2')
         .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
         .downcase
   end
+
+  # Transform snake case to capitalized
+  def snake_to_capital
+    split('_').map(&:capitalize).join
+  end
 end

data/lib/aspera/command_line_builder.rb

@@ -4,72 +4,69 @@ require 'aspera/log'
 require 'aspera/assert'
 require 'yaml'
 module Aspera
-  # helper class to build command line from a parameter list (key-value hash)
-  # constructor takes hash: { 'param1':'value1', ...}
-  # process_param is called repeatedly with all known parameters
-  # add_env_args is called to get resulting param list and env var (also checks that all params were used)
+  # Helper class to build command line from a parameter list (key-value hash)
+  # Constructor takes hash: `{ 'param1':'value1', ...}`
+  # `process_param` is called repeatedly with all known parameters
+  # `add_env_args` is called to get resulting param list and env var (also checks that all params were used)
   class CommandLineBuilder
-    # description    [String]       Description
-    # type           [String,Array] Accepted type(s) for non-enum
-    # default        [String]       Default value if not specified
-    # enum           [Array]        Set with list of values for enum types accepted in transfer spec
-    # items          [Array]
-    # properties     [Array]
-    # x-cli-envvar   [String]       Name of env var
-    # x-cli-option   [String]       Command line option (starts with "-")
-    # x-cli-switch   [Bool]         true if option has no arg, else by default option has a value
-    # x-cli-special  [Bool]         true if special handling (defered)
-    # x-cli-convert  [String,Hash]  Method name for Convert object or Conversion for enum ts to arg
-    # x-agents       [Array]        Supported agents (for doc only), if not specified: all
-    # x-ts-name      [Bool,String]  (async) true if same name in transfer spec, else real name in transfer spec, else ignored
-    # x-ts-convert   [String]       (async) Method name for Convert object
-    # x-deprecation  [String]       Deprecation message for doc
-    PROPERTY_KEYS = %w[
-      description
-      type
-      default
-      enum
-      items
-      properties
-      required
-      $comment
-      x-cli-envvar
-      x-cli-option
-      x-cli-switch
-      x-cli-special
-      x-cli-convert
-      x-agents
-      x-ts-name
-      x-deprecation
+    # Supported keys in JSON schema
+    PROPERTY_KEYS = [
+      'description',    # [String]       Description
+      'type',           # [String,Array] Accepted type(s) for non-enum
+      'default',        # [String]       Default value if not specified
+      'enum',           # [Array]        Set with list of values for enum types accepted in transfer spec
+      'items',          # [Array]
+      'properties',     # [Array]
+      'required',       # [Array]
+      '$comment',       # [String]
+      'x-cli-envvar',   # [String]       Name of env var
+      'x-cli-option',   # [String]       Command line option (starts with "-")
+      'x-cli-short',    # [String]       Command line option (starts with "-")
+      'x-cli-switch',   # [Bool]         `true` if option has no arg, else by default option has a value
+      'x-cli-special',  # [Bool]         `true` if special handling (deferred)
+      'x-cli-convert',  # [String,Hash]  Method name for Convert object or Conversion for enum ts to arg
+      'x-agents',       # [Array]        Supported agents (for doc only), if not specified: all
+      'x-ts-name',      # [Bool,String]  (async) true if same name in transfer spec, else real name in transfer spec, else ignored
+      'x-ts-convert',   # [String]       (async) Name of methods to convert value from transfer spec to `conf` API.
+      'x-deprecation'   # [String]       Deprecation message for doc
     ].freeze
 
-    CLI_AGENT = 'direct'
-
-    private_constant :PROPERTY_KEYS, :CLI_AGENT
+    private_constant :PROPERTY_KEYS
 
     class << self
-      # @return true if given agent supports that field
+      # Called by provider of definition before constructor of this class so that schema has all mandatory fields
+      def read_schema(folder, name, ascp: false)
+        schema = YAML.load_file(File.join(folder, "#{name}.schema.yaml"))
+        validate_schema(schema, ascp: ascp)
+      end
+
+      # @param agent      [Symbol] Transfer agent name
+      # @param properties [Hash]   Transfer spec parameter information
+      # @return [Boolean] `true` if given agent supports that field
       def supported_by_agent(agent, properties)
-        !properties.key?('x-agents') || properties['x-agents'].include?(agent)
+        !properties.key?('x-agents') || properties['x-agents'].include?(agent.to_s)
       end
 
-      # fill default values
-      def adjust_properties_defaults(properties)
-        properties.each do |name, info|
+      private
+
+      # Fill default values for some fields in the schema
+      # @param schema [Hash] The JSON schema
+      # @param ascp [Bool] `true` if ascp
+      def validate_schema(schema, ascp: false)
+        direct_props = %w[x-cli-option x-cli-envvar x-cli-special].freeze
+        schema['properties'].each do |name, info|
           Aspera.assert_type(info, Hash){"#{info.class} for #{name}"}
           unsupported_keys = info.keys - PROPERTY_KEYS
           Aspera.assert(unsupported_keys.empty?){"Unsupported definition keys: #{unsupported_keys}"}
-          # by default : string, unless it's without arg
-          info['type'] ||= info['x-cli-switch'] ? 'boolean' : 'string'
-          # add default cli option name if not present, and if supported in "direct".
-          info['x-cli-option'] = "--#{name.to_s.tr('_', '-')}" if !info.key?('x-cli-option') && !info['x-cli-envvar'] && (info.key?('x-cli-switch') || supported_by_agent(CLI_AGENT, info))
+          Aspera.assert(info.key?('type') || info.key?('enum')){"Missing type for #{name} in #{schema['description']}"}
+          Aspera.assert(info['type'].eql?('boolean')){"switch must be bool: #{name}"} if info['x-cli-switch'] && !info['x-cli-special']
+          info['x-cli-option'] = "--#{name.to_s.tr('_', '-')}" if info['x-cli-option'].eql?(true) || (info['x-cli-switch'].eql?(true) && !info.key?('x-cli-option'))
+          Aspera.assert(direct_props.any?{ |i| info.key?(i)}, type: :warn){name} if ascp && supported_by_agent(:direct, info)
           info.freeze
+          validate_schema(info, ascp: ascp) if info['type'].eql?('object') && info['properties']
+          validate_schema(info['items'], ascp: ascp) if info['type'].eql?('array') && info['items'] && info['items']['properties']
         end
-      end
-
-      # Called by provider of definition before constructor of this class so that schema has all mandatory fields
-      def read_schema(source_path, name)
-        YAML.load_file(File.join(File.dirname(source_path), "#{name}.schema.yaml"))
+        schema
       end
     end
 
@@ -98,10 +95,10 @@ module Aspera
     # Add processed parameters to env and args, warns about unused parameters
     # @param [Hash] env_args with :env and :args
     def add_env_args(env_args)
-      Log.log.debug{"add_env_args: ENV=#{@result[:env]}, ARGS=#{@result[:args]}"}
+      Log.dump(:env_args, @result)
       # warn about non translated arguments
       @object.each_pair do |name, value|
-        Log.log.warn{raise "Unknown transfer spec parameter: #{name} = \"#{value}\""} unless @processed_parameters.include?(name)
+        Log.log.warn{"Unknown transfer spec parameter: #{name} = \"#{value}\""} unless @processed_parameters.include?(name)
       end
       # set result
       env_args[:env].merge!(@result[:env])
@@ -109,9 +106,10 @@ module Aspera
       return
     end
 
-    # add options directly to command line
-    def add_command_line_options(options)
-      return if options.nil?
+    # Add options directly to command line
+    def add_command_line_options(*options)
+      options = options.first if options.first.is_a?(Array) && options.length.eql?(1)
+      Aspera.assert_type(options, Array)
       options.each{ |o| @result[:args].push(o.to_s)}
     end
 
@@ -178,7 +176,7 @@ module Aspera
         parameter_value = converted_value
       end
 
-      return unless self.class.supported_by_agent(CLI_AGENT, properties)
+      return unless self.class.supported_by_agent(:direct, properties)
 
       if read
         # just get value (deferred)
@@ -198,13 +196,13 @@ module Aspera
         else Aspera.error_unexpected_value(parameter_value){name}
         end
         # add_param = !add_param if properties[:add_on_false]
-        add_command_line_options([properties['x-cli-option']]) if add_param
+        add_command_line_options(properties['x-cli-option']) if add_param
       else
         # transform into command line option with value
         # parameter_value=parameter_value.to_s if parameter_value.is_a?(Integer)
         parameter_value = [parameter_value] unless parameter_value.is_a?(Array)
         # if transfer_spec value is an array, applies option many times
-        parameter_value.each{ |v| add_command_line_options([properties['x-cli-option'], v])}
+        parameter_value.each{ |v| add_command_line_options(properties['x-cli-option'], v)}
       end
     end
   end

data/lib/aspera/command_line_converter.rb

@@ -23,8 +23,9 @@ module Aspera
         end
       end
 
+      # Kbps to bps
       def kbps_to_bps(value)
-        1000 * value
+        1000 * value.to_i
       end
     end
   end

data/lib/aspera/coverage.rb

@@ -5,10 +5,10 @@ if ENV.key?('ENABLE_COVERAGE')
   require 'simplecov'
   require 'securerandom'
   # compute development top folder based on this source location
-  development_root = 3.times.inject(File.realpath(__FILE__)){ |p, _| File.dirname(p)}
+  development_root = File.dirname(File.realpath(__FILE__), 3)
   SimpleCov.root(development_root)
   SimpleCov.enable_for_subprocesses if SimpleCov.respond_to?(:enable_for_subprocesses)
-  # keep cache data for 1 day (must be longer that time to run the whole test suite)
+  # keep cache data for 1 day (must be longer than time to run the whole test suite)
   SimpleCov.merge_timeout(86400)
   SimpleCov.command_name(SecureRandom.uuid)
   SimpleCov.at_exit do

data/lib/aspera/data_repository.rb

@@ -19,7 +19,7 @@ module Aspera
     # @return [String] decoded data
     def item(name)
       index = ELEMENTS.index(name)
-      raise ArgumentError, "unknown data item #{name} (#{name.class})" unless index
+      raise ParameterError, "Unknown data item #{name} (#{name.class})" unless index
       raw_data = data(START_INDEX + index)
       case name
       when :dsa, :rsa

data/lib/aspera/environment.rb

@@ -5,7 +5,9 @@ require 'aspera/log'
 require 'aspera/assert'
 require 'rbconfig'
 require 'singleton'
+require 'open3'
 require 'English'
+require 'shellwords'
 
 # cspell:words MEBI mswin bccwin
 
@@ -38,6 +40,8 @@ module Aspera
     WINDOWS_FILENAME_INVALID_CHARACTERS = '<>:"/\\|?*'
     REPLACE_CHARACTER = '_'
 
+    RB_EXT = '.rb'
+
     class << self
       def ruby_version
         return RbConfig::CONFIG['RUBY_PROGRAM_VERSION']
@@ -54,9 +58,9 @@ module Aspera
       end
 
       # Generate log line for external program with arguments
-      # @param env [Hash, nil]   environment variables
-      # @param exec [String]     path to executable
-      # @param args [Array, nil] arguments
+      # @param exec [String]     Path to executable
+      # @param args [Array, nil] Arguments
+      # @param env [Hash, nil]   Environment variables
       # @return [String] log line with environment, program and arguments
       def log_spawn(exec:, args: nil, env: nil)
         [
@@ -69,65 +73,70 @@ module Aspera
 
       # Start process in background
       # caller can call Process.wait on returned value
-      # @param exec    [String]     path to executable
-      # @param args    [Array, nil] arguments for executable
-      # @param env     [Hash, nil]  environment variables
-      # @param options [Hash, nil]  spawn options
+      # @param exec    [String]     Path to executable
+      # @param args    [Array, nil] Arguments for executable
+      # @param env     [Hash, nil]  Environment variables
+      # @param kwargs  [Hash]       Options for `Process.spawn`
       # @return [String]            PID of process
       # @raise  [Exception]         if problem
-      def secure_spawn(exec:, args: nil, env: nil, **options)
+      def secure_spawn(exec:, args: nil, env: nil, **kwargs)
         Aspera.assert_type(exec, String)
         Aspera.assert_type(args, Array, NilClass)
         Aspera.assert_type(env, Hash, NilClass)
-        Aspera.assert_type(options, Hash, NilClass)
         Log.log.debug{log_spawn(exec: exec, args: args, env: env)}
-        # start ascp in separate process
         spawn_args = []
         spawn_args.push(env) unless env.nil?
         spawn_args.push([exec, exec])
         spawn_args.concat(args) unless args.nil?
-        opts = {close_others: true}
-        opts.merge!(options) unless options.nil?
-        ascp_pid = Process.spawn(*spawn_args, **opts)
-        Log.log.debug{"pid: #{ascp_pid}"}
-        return ascp_pid
+        kwargs[:close_others] = true unless kwargs.key?(:close_others)
+        # Start separate process in background
+        pid = Process.spawn(*spawn_args, **kwargs)
+        Log.dump(:pid, pid)
+        return pid
       end
 
-      # start process and wait for completion
-      # @param env [Hash, nil]   environment variables
-      # @param exec [String]     path to executable
-      # @param args [Array, nil] arguments
-      # @return [String] PID of process
-      def secure_execute(exec:, args: nil, env: nil, **system_args)
+      # Start process (not in shell) and wait for completion.
+      # By default, sets `exception: true` in `kwargs`
+      # @param exec   [String]     Path to executable
+      # @param args   [Array, nil] Arguments
+      # @param env    [Hash, nil]  Environment variables
+      # @param kwargs [Hash]       Arguments for `Kernel.system`
+      # @return `nil`
+      # @raise [RuntimeError] if problem
+      def secure_execute(exec:, args: nil, env: nil, **kwargs)
         Aspera.assert_type(exec, String)
         Aspera.assert_type(args, Array, NilClass)
         Aspera.assert_type(env, Hash, NilClass)
         Log.log.debug{log_spawn(exec: exec, args: args, env: env)}
-        # start in separate process
+        Log.dump(:kwargs, kwargs, level: :trace1)
         spawn_args = []
         spawn_args.push(env) unless env.nil?
-        # ensure no shell expansion
+        # Ensure no shell expansion
         spawn_args.push([exec, exec])
         spawn_args.concat(args) unless args.nil?
-        kwargs = {exception: true}
-        kwargs.merge!(system_args)
+        # By default: exception on error
+        kwargs[:exception] = true unless kwargs.key?(:exception)
+        # Start in separate process
         Kernel.system(*spawn_args, **kwargs)
         nil
       end
 
       # Execute process and capture stdout
-      # @param exec [String] path to executable
-      # @param args [Array] arguments to executable
-      # @param opts [Hash] options to capture3
+      # @param exec   [String] path to executable
+      # @param args   [Array]  arguments to executable
+      # @param kwargs [Hash]   options to Open3.capture3
       # @return stdout of executable or raise exception
-      def secure_capture(exec:, args: [], exception: true, **opts)
+      def secure_capture(exec:, args: [], env: nil, exception: true, **kwargs)
         Aspera.assert_type(exec, String)
         Aspera.assert_type(args, Array)
-        Aspera.assert_type(opts, Hash)
-        Log.log.debug{log_spawn(exec: exec, args: args)}
-        Log.dump(:opts, opts, level: :trace2)
-        Log.dump(:ENV, ENV.to_h, level: :trace1)
-        stdout, stderr, status = Open3.capture3(exec, *args, **opts)
+        Log.log.debug{log_spawn(exec: exec, args: args, env: env)}
+        Log.dump(:kwargs, kwargs, level: :trace2)
+        # Log.dump(:ENV, ENV.to_h, level: :trace1)
+        capture_args = []
+        capture_args.push(env) unless env.nil?
+        capture_args.push(exec)
+        capture_args.concat(args)
+        stdout, stderr, status = Open3.capture3(*capture_args, **kwargs)
         Log.log.debug{"status=#{status}, stderr=#{stderr}"}
         Log.log.trace1{"stdout=#{stdout}"}
         raise "process failed: #{status.exitstatus} (#{stderr})" if !status.success? && exception
@@ -186,7 +195,7 @@ module Aspera
       end
     end
     attr_accessor :url_method, :file_illegal_characters
-    attr_reader :os, :cpu, :executable_extension, :default_gui_mode
+    attr_reader :os, :cpu, :default_gui_mode
 
     def initialize
       initialize_fields
@@ -218,7 +227,7 @@ module Aspera
           CPU_ARM64
         else Aspera.error_unexpected_value(RbConfig::CONFIG['host_cpu']){'host_cpu'}
         end
-      @executable_extension = @os.eql?(OS_WINDOWS) ? 'exe' : nil
+      @executable_extension = @os.eql?(OS_WINDOWS) ? '.exe' : nil
       # :text or :graphical depending on the environment
       @default_gui_mode =
         if [Environment::OS_WINDOWS, Environment::OS_MACOS].include?(os) ||
@@ -239,8 +248,10 @@ module Aspera
       "#{@os}-#{@cpu}"
     end
 
-    # executable file extension for current OS
-    def exe_file(name)
+    # Add executable file extension (e.g. ".exe") for current OS
+    # @param name [String,nil] Path or file name
+    # @return [String] Executable name with extension
+    def exe_file(name = nil)
       return name unless @executable_extension
       return "#{name}#{@executable_extension}"
     end
@@ -314,9 +325,8 @@ module Aspera
       # Windows does not allow file name:
       # - with control characters anywhere
       # - ending with space or dot
-      filename = filename
-        .gsub(/[\x00-\x1F\x7F]/, safe_char)
-        .sub(/[. ]+\z/, safe_char)
+      filename = filename.gsub(/[\x00-\x1F\x7F]/, safe_char)
+      filename = filename.chop while filename.end_with?(' ', '.')
       if @file_illegal_characters&.size.to_i >= 2
         # replace all illegal characters with safe_char
         filename = filename.tr(@file_illegal_characters[1..-1], safe_char)

data/lib/aspera/faspex_gw.rb

@@ -8,10 +8,12 @@ require 'json'
 module Aspera
   # Simulate the Faspex 4 /send API and creates a package on Aspera on Cloud or Faspex 5
   class Faspex4GWServlet < WEBrick::HTTPServlet::AbstractServlet
+    AOC_API = 'Aspera::Api::AoC'
+    FX_API = 'Aspera::Api::Faspex'
     # @param app_api     [Rest]   API object
     # @param app_context [String] workspace id (aoc only)
     def initialize(server, app_api, app_context)
-      Aspera.assert_values(app_api.class.name, ['Aspera::Api::AoC', 'Aspera::Rest'])
+      Aspera.assert_values(app_api.class.name, [AOC_API, FX_API])
       super(server)
       @app_api = app_api
       @app_context = app_context
@@ -49,11 +51,11 @@ module Aspera
       transfer_spec = @app_api.call(
         operation:    'POST',
         subpath:      "packages/#{package['id']}/transfer_spec/upload",
-        query:        {transfer_type: Cli::Plugins::Faspex5::TRANSFER_CONNECT},
+        query:        {transfer_type: Api::Faspex::TRANSFER_CONNECT},
         content_type: Rest::MIME_JSON,
         body:         {paths: [{'destination'=>'/'}]},
         headers:      {'Accept' => Rest::MIME_JSON}
-      )[:data]
+      )
       transfer_spec.delete('authentication')
       # but we place it in a Faspex package creation response
       return {
@@ -72,9 +74,9 @@ module Aspera
           # compare string, as class is not yet known here
           faspex_package_create_result =
             case @app_api.class.name
-            when 'Aspera::Api::AoC'
+            when AOC_API
               faspex4_send_to_aoc(faspex_pkg_parameters)
-            when 'Aspera::Rest'
+            when FX_API
               faspex4_send_to_faspex5(faspex_pkg_parameters)
             else Aspera.error_unexpected_value(@app_api.class.name)
             end