aspera-cli 4.21.1 → 4.22.0

data/lib/aspera/command_line_builder.rb

@@ -2,79 +2,101 @@
 
 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)
   class CommandLineBuilder
-    # parameter with one of those tags is a command line option with --
-    CLI_OPTION_TYPE_SWITCH = %i[opt_without_arg opt_with_arg].freeze
-    CLI_OPTION_TYPES = %i[special ignore envvar].concat(CLI_OPTION_TYPE_SWITCH).freeze
-    OPTIONS_KEYS = %i[desc accepted_types default enum agents required cli ts deprecation].freeze
-    CLI_KEYS = %i[type switch convert variable].freeze
-
-    private_constant :CLI_OPTION_TYPE_SWITCH, :CLI_OPTION_TYPES, :OPTIONS_KEYS, :CLI_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
+    # 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-tspec        [Bool,String]  (async) true if same name in transfer spec, else name in transfer spec, else ignored
+    # x-deprecation  [String]       Deprecation message for doc
+    SCHEMA_KEYS = %w[
+      description
+      type
+      default
+      enum
+      required
+      $comment
+      x-cli-envvar
+      x-cli-option
+      x-cli-switch
+      x-cli-special
+      x-cli-convert
+      x-agents
+      x-tspec
+      x-deprecation
+    ].freeze
+
+    CLI_AGENT = 'direct'
+
+    private_constant :SCHEMA_KEYS, :CLI_AGENT
 
     class << self
-      # transform yes/no to true/false
-      def yes_to_true(value)
-        case value
-        when 'yes' then return true
-        when 'no' then return false
-        else Aspera.error_unexpected_value(value){'only: yes or no: '}
-        end
+      # @return true if given agent supports that field
+      def supported_by_agent(agent, properties)
+        !properties.key?('x-agents') || properties['x-agents'].include?(agent)
       end
 
-      # Called by provider of definition before constructor of this class so that params_definition has all mandatory fields
-      def normalize_description(full_description)
-        full_description.each do |name, options|
-          Aspera.assert_type(options, Hash){name}
-          unsupported_keys = options.keys - OPTIONS_KEYS
+      # Called by provider of definition before constructor of this class so that schema has all mandatory fields
+      def read_schema(source_path, suffix=nil)
+        suffix = "_#{suffix}" unless suffix.nil?
+        schema = YAML.load_file("#{source_path[0..-4]}#{suffix}.schema.yaml")
+        schema['properties'].each do |name, properties|
+          Aspera.assert_type(properties, Hash){name}
+          unsupported_keys = properties.keys - SCHEMA_KEYS
           Aspera.assert(unsupported_keys.empty?){"Unsupported definition keys: #{unsupported_keys}"}
-          Aspera.assert(options.key?(:cli)){"Missing key: cli for #{name}"}
-          Aspera.assert_type(options[:cli], Hash){'Key: cli'}
-          Aspera.assert(options[:cli].key?(:type)){'Missing key: cli.type'}
-          Aspera.assert_values(options[:cli][:type], CLI_OPTION_TYPES){"Unsupported processing type for #{name}"}
-          # by default : optional
-          options[:mandatory] ||= false
-          options[:desc] ||= ''
-          options[:desc] = "DEPRECATED: #{options[:deprecation]}\n#{options[:desc]}" if options.key?(:deprecation)
-          cli = options[:cli]
-          unsupported_cli_keys = cli.keys - CLI_KEYS
-          Aspera.assert(unsupported_cli_keys.empty?){"Unsupported cli keys: #{unsupported_cli_keys}"}
           # by default : string, unless it's without arg
-          options[:accepted_types] ||= options[:cli][:type].eql?(:opt_without_arg) ? :bool : :string
-          # single type is placed in array
-          options[:accepted_types] = [options[:accepted_types]] unless options[:accepted_types].is_a?(Array)
-          # add default switch name if not present
-          if !cli.key?(:switch) && cli.key?(:type) && CLI_OPTION_TYPE_SWITCH.include?(cli[:type])
-            cli[:switch] = '--' + name.to_s.tr('_', '-')
-          end
+          properties['type'] ||= properties['x-cli-switch'] ? 'boolean' : 'string'
+          # add default cli option name if not present, and if supported in "direct".
+          properties['x-cli-option'] = '--' + name.to_s.tr('_', '-') if !properties.key?('x-cli-option') && !properties['x-cli-envvar'] && (properties.key?('x-cli-switch') || supported_by_agent(CLI_AGENT, properties))
+          properties.freeze
         end
+        schema['required'] = [] unless schema.key?('required')
+        schema.freeze
       end
     end
 
-    attr_reader :params_definition
-
-    # @param [Hash] param_hash with parameters
-    # @param [Hash] params_definition with definition of parameters
-    def initialize(param_hash, params_definition)
-      @param_hash = param_hash # keep reference so that it can be modified by caller before calling `process_params`
-      @params_definition = params_definition
+    # @param [Hash] object with parameters
+    # @param [Hash] schema JSON schema
+    def initialize(object, schema, convert)
+      @object = object # keep reference so that it can be modified by caller before calling `process_params`
+      @schema = schema
+      @convert = convert
       @result = {
         env:  {},
         args: []
       }
-      @used_param_names = []
+      @processed_parameters = []
+    end
+
+    # Change required-ness of property in schema
+    def required(name, required)
+      if required
+        @schema['required'].push(name) unless @schema['required'].include?(name)
+      else
+        @schema['required'].delete(name)
+      end
     end
 
-    # add processed parameters to env and args, warns about unused parameters
+    # 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]}"}
       # warn about non translated arguments
-      @param_hash.each_pair{|key, val|Log.log.warn{"unrecognized parameter: #{key} = \"#{val}\""} if !@used_param_names.include?(key)}
+      @object.each_pair do |name, value|
+        Log.log.warn{raise "Unknown transfer spec parameter: #{name} = \"#{value}\""} unless @processed_parameters.include?(name)
+      end
       # set result
       env_args[:env].merge!(@result[:env])
       env_args[:args].concat(@result[:args])
@@ -84,11 +106,11 @@ module Aspera
     # add options directly to command line
     def add_command_line_options(options)
       return if options.nil?
-      options.each{|o|@result[:args].push(o.to_s)}
+      options.each{ |o| @result[:args].push(o.to_s)}
     end
 
     def process_params
-      @params_definition.each_key do |k|
+      @schema['properties'].each_key do |k|
         process_param(k)
       end
     end
@@ -103,81 +125,80 @@ module Aspera
     # @param name [String] of parameter
     # @param read [TrueClass,FalseClass] read and return value of parameter instead of normal processing (for special)
     def process_param(name, read: false)
-      options = @params_definition[name]
+      properties = @schema['properties'][name]
       # should not happen
-      if options.nil?
+      if properties.nil?
         Log.log.warn{"Unknown parameter #{name}"}
         return
       end
-      processing_type = read ? :get_value : options[:cli][:type]
-      # check mandatory parameter (nil is valid value)
-      raise Transfer::Error, "Missing mandatory parameter: #{name}" if options[:mandatory] && !@param_hash.key?(name)
-      parameter_value = @param_hash[name]
+      # check mandatory parameter (nil is valid value), TODO: change exception ?
+      raise Transfer::Error, "Missing mandatory parameter: #{name}" if @schema['required'].include?(name) && !properties['x-cli-special'] && !@object.key?(name)
+      parameter_value = @object[name]
       # no default setting
-      # parameter_value=options[:default] if parameter_value.nil? and options.has_key?(:default)
+      # parameter_value=properties['default'] if parameter_value.nil? and properties.has_key?('default')
       # Check parameter type
-      expected_classes = options[:accepted_types].map do |type_symbol|
-        case type_symbol
-        when :string then String
-        when :array then Array
-        when :hash then Hash
-        when :int then Integer
-        when :bool then [TrueClass, FalseClass]
-        else Aspera.error_unexpected_value(type_symbol)
-        end
-      end.flatten
+      expected_classes =
+        [properties['type']].flatten.map do |type|
+          case type
+          when 'string' then [String]
+          when 'array' then [Array]
+          when 'object' then [Hash]
+          when 'integer' then [Integer]
+          when 'boolean' then [TrueClass, FalseClass]
+          else Aspera.error_unexpected_value(properties['type'])
+          end
+        end.flatten
       # check that value is of expected type
-      raise Transfer::Error, "#{name} is : #{parameter_value.class} (#{parameter_value}), shall be #{options[:accepted_types]}, " \
+      raise Transfer::Error, "#{name} is : #{parameter_value.class} (#{parameter_value}), shall be #{properties['type']}, " \
         unless parameter_value.nil? || expected_classes.include?(parameter_value.class)
       # special processing will be requested with type get_value
-      @used_param_names.push(name) unless processing_type.eql?(:special)
+      @processed_parameters.push(name) if !properties['x-cli-special'] || read
 
       # process only non-nil values
       return nil if parameter_value.nil?
 
-      # check that value is of an accepted type (string, int bool)
-      raise "Enum value #{parameter_value} is not allowed for #{name}" if options.key?(:enum) && !options[:enum].include?(parameter_value)
+      # check that value is of an accepted type (string, integer, boolean)
+      raise "Enum value #{parameter_value} is not allowed for #{name}" if properties.key?('enum') && !properties['enum'].include?(parameter_value)
 
       # convert some values if value on command line needs processing from value in structure
-      case options[:cli][:convert]
-      when Hash
-        # translate using conversion table
-        new_value = options[:cli][:convert][parameter_value]
-        raise "unsupported value: #{parameter_value}, expect: #{options[:cli][:convert].keys.join(', ')}" if new_value.nil?
-        parameter_value = new_value
-      when String
-        # :convert has name of class and encoding method
-        conversion_class, conversion_method = options[:cli][:convert].split('.')
-        converted_value = Kernel.const_get(conversion_class).send(conversion_method, parameter_value)
-        raise Transfer::Error, "unsupported #{name}: #{parameter_value}" if converted_value.nil?
+      if (convert = properties['x-cli-convert'])
+        converted_value =
+          case convert
+          when Hash then convert[parameter_value]
+          when String then @convert.send(convert, parameter_value)
+          else Aspera.error_unexpected_value(convert){"Conversion type for #{name} is Hash or String only."}
+          end
+        raise "No conversion for: #{name}=#{parameter_value}" if converted_value.nil?
         parameter_value = converted_value
-      when NilClass
-      else Aspera.error_unexpected_value(options[:cli][:convert].class)
       end
 
-      case processing_type
-      when :get_value # just get value (deferred)
+      return unless self.class.supported_by_agent(CLI_AGENT, properties)
+
+      if read
+        # just get value (deferred)
         return parameter_value
-      when :ignore, :special # ignore this parameter or process later
+      elsif properties['x-cli-special']
+        # process later
         return
-      when :envvar # set in env var
-        Aspera.assert(options[:cli].key?(:variable)){'missing key: cli.variable'}
-        @result[:env][options[:cli][:variable]] = parameter_value
-      when :opt_without_arg # if present and true : just add option without value
+      elsif properties.key?('x-cli-envvar')
+        # set in env var
+        @result[:env][properties['x-cli-envvar']] = parameter_value
+      elsif properties['x-cli-switch']
+        # if present and true : just add option without value
         add_param = false
         case parameter_value
         when false then nil # nothing to put on command line, no creation by default
         when true then add_param = true
         else Aspera.error_unexpected_value(parameter_value){name}
         end
-        add_param = !add_param if options[:add_on_false]
-        add_command_line_options([options[:cli][:switch]]) if add_param
-      when :opt_with_arg # transform into command line option with value
+        # add_param = !add_param if properties[:add_on_false]
+        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([options[:cli][:switch], v])}
-      else Aspera.error_unexpected_value(processing_type){processing_type.class.name}
+        parameter_value.each{ |v| add_command_line_options([properties['x-cli-option'], v])}
       end
     end
   end

data/lib/aspera/coverage.rb

@@ -5,7 +5,7 @@ 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 = 3.times.inject(File.realpath(__FILE__)){ |p, _| File.dirname(p)}
   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)
@@ -20,14 +20,17 @@ if ENV.key?('ENABLE_COVERAGE')
   # lines with those words are ignored from coverage
   no_cov_functions = %w[error_unreachable_line error_unexpected_value Log.log.trace].freeze
   SimpleCov.start do
-    add_filter 'lib/aspera/cli/plugins/faspex.rb'
-    add_filter 'lib/aspera/node_simulator.rb'
-    add_filter 'lib/aspera/keychain/macos_security.rb'
+    # assert usually do not trigger
     add_filter do |source_file|
       source_file.lines.each do |line|
-        line.skipped! if no_cov_functions.any?{|i|line.src.include?(i)}
+        line.skipped! if no_cov_functions.any?{ |i| line.src.include?(i)}
       end
       false
     end
+    # no coverage in these files
+    add_filter 'lib/aspera/cli/plugins/faspex.rb'
+    add_filter 'lib/aspera/node_simulator.rb'
+    add_filter 'lib/aspera/keychain/macos_security.rb'
+    add_filter 'lib/aspera/assert.rb'
   end
 end

data/lib/aspera/environment.rb

@@ -103,29 +103,34 @@ module Aspera
       def log_spawn(exec:, args: nil, env: nil)
         [
           'execute:'.red,
-          env&.map{|k, v| "#{k}=#{Shellwords.shellescape(v)}"},
+          env&.map{ |k, v| "#{k}=#{Shellwords.shellescape(v)}"},
           Shellwords.shellescape(exec),
-          args&.map{|a|Shellwords.shellescape(a)}
+          args&.map{ |a| Shellwords.shellescape(a)}
         ].compact.flatten.join(' ')
       end
 
-      # start process in background, or raise exception
+      # Start process in background
       # caller can call Process.wait on returned value
-      # @param env [Hash, nil]   environment variables
-      # @param exec [String]     path to executable
-      # @param args [Array, nil] arguments
-      # @return [String] PID of process
-      def secure_spawn(exec:, args: nil, env: nil)
+      # @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
+      # @return [String]            PID of process
+      # @raise  [Exception]         if problem
+      def secure_spawn(exec:, args: nil, env: nil, **options)
         Aspera.assert_type(exec, String)
         Aspera.assert_type(args, Array) unless args.nil?
         Aspera.assert_type(env, Hash) unless env.nil?
-        Log.log.debug {log_spawn(exec: exec, args: args, env: env)}
+        Aspera.assert_type(options, Hash) unless options.nil?
+        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?
-        ascp_pid = Process.spawn(*spawn_args, close_others: true)
+        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
       end
@@ -135,29 +140,33 @@ module Aspera
       # @param exec [String]     path to executable
       # @param args [Array, nil] arguments
       # @return [String] PID of process
-      def secure_execute(exec:, args: nil, env: nil)
+      def secure_execute(exec:, args: nil, env: nil, **system_args)
         Aspera.assert_type(exec, String)
         Aspera.assert_type(args, Array) unless args.nil?
         Aspera.assert_type(env, Hash) unless env.nil?
-        Log.log.debug {log_spawn(exec: exec, args: args, env: env)}
-        # start ascp in separate process
+        Log.log.debug{log_spawn(exec: exec, args: args, env: env)}
+        # start in separate process
         spawn_args = []
         spawn_args.push(env) unless env.nil?
+        # ensure no shell expansion
         spawn_args.push([exec, exec])
         spawn_args.concat(args) unless args.nil?
-        Kernel.system(*spawn_args, exception: true)
+        kwargs = {exception: true}
+        kwargs.merge!(system_args)
+        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
-      # @return stdout of executable or raise expcetion
+      # @return stdout of executable or raise exception
       def secure_capture(exec:, args: [], **opts)
         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.log.debug{log_spawn(exec: exec, args: args)}
         stdout, stderr, status = Open3.capture3(exec, *args, **opts)
         Log.log.debug{"status=#{status}, stderr=#{stderr}"}
         Log.log.trace1{"stdout=#{stdout}"}
@@ -247,7 +256,7 @@ module Aspera
     # https://www.gnu.org/software/libc/manual/html_node/Locale-Categories.html
     # https://pubs.opengroup.org/onlinepubs/7908799/xbd/envvar.html
     def terminal_supports_unicode?
-      @terminal_supports_unicode = self.class.terminal? && %w(LC_ALL LC_CTYPE LANG).any?{|var|ENV[var]&.include?('UTF-8')} if @terminal_supports_unicode.nil?
+      @terminal_supports_unicode = self.class.terminal? && %w(LC_ALL LC_CTYPE LANG).any?{ |var| ENV[var]&.include?('UTF-8')} if @terminal_supports_unicode.nil?
       return @terminal_supports_unicode
     end
 

data/lib/aspera/faspex_gw.rb

@@ -8,8 +8,8 @@ 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
-    # @param app_api
-    # @param app_context [String]
+    # @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'])
       super(server)
@@ -32,7 +32,7 @@ module Aspera
       created_package = @app_api.create_package_simple(package_data, true, nil)
       # but we place it in a Faspex package creation response
       return {
-        'links'         => { 'status' => 'unused' },
+        'links'         => {'status' => 'unused'},
         'xfer_sessions' => [created_package[:spec]]
       }
     end
@@ -42,22 +42,22 @@ module Aspera
       package_data = {
         'title'      => faspex_pkg_delivery['title'],
         'note'       => faspex_pkg_delivery['note'],
-        'recipients' => faspex_pkg_delivery['recipients'].map{|name|{'name'=>name}}
+        'recipients' => faspex_pkg_delivery['recipients'].map{ |name| {'name'=>name}}
       }
       package = @app_api.create('packages', package_data)
       # TODO: option to send from remote source or httpgw
       transfer_spec = @app_api.call(
-        operation:   'POST',
-        subpath:     "packages/#{package['id']}/transfer_spec/upload",
-        headers:     {'Accept' => 'application/json'},
-        query:       {transfer_type: Cli::Plugins::Faspex5::TRANSFER_CONNECT},
-        body:        {paths: [{'destination'=>'/'}]},
-        body_type:   :json
+        operation:    'POST',
+        subpath:      "packages/#{package['id']}/transfer_spec/upload",
+        query:        {transfer_type: Cli::Plugins::Faspex5::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 {
-        'links'         => { 'status' => 'unused' },
+        'links'         => {'status' => 'unused'},
         'xfer_sessions' => [transfer_spec]
       }
     end
@@ -80,18 +80,18 @@ module Aspera
             end
           Log.log.info{"faspex_package_create_result=#{faspex_package_create_result}"}
           response.status = 200
-          response.content_type = 'application/json'
+          response.content_type = Rest::MIME_JSON
           response.body = JSON.generate(faspex_package_create_result)
         rescue => e
           response.status = 500
-          response['Content-Type'] = 'application/json'
+          response['Content-Type'] = Rest::MIME_JSON
           response.body = {error: e.message, stacktrace: e.backtrace}.to_json
           Log.log.error(e.message)
           Log.log.debug{e.backtrace.join("\n")}
         end
       else
         response.status = 400
-        response['Content-Type'] = 'application/json'
+        response['Content-Type'] = Rest::MIME_JSON
         response.body = {error: 'Unsupported endpoint'}.to_json
       end
     end

data/lib/aspera/faspex_postproc.rb

@@ -15,7 +15,8 @@ module Aspera
       Aspera.assert_type(parameters, Hash)
       @parameters = parameters.symbolize_keys
       Log.log.debug{Log.dump(:post_proc_parameters, @parameters)}
-      raise "unexpected key in parameters config: only: #{ALLOWED_PARAMETERS.join(', ')}" if @parameters.keys.any?{|k|!ALLOWED_PARAMETERS.include?(k)}
+      not_allowed = @parameters.keys - ALLOWED_PARAMETERS
+      raise "unsupported parameters: #{not_allowed.join(', ')}" unless not_allowed.empty?
       @parameters[:script_folder] ||= '.'
       @parameters[:fail_on_error] ||= false
       @parameters[:timeout_seconds] ||= 60
@@ -29,17 +30,17 @@ module Aspera
         # only accept requests on the root
         if !request.path.start_with?(@parameters[:root])
           response.status = 400
-          response['Content-Type'] = 'application/json'
+          response['Content-Type'] = Rest::MIME_JSON
           response.body = {status: 'error', message: 'Request outside domain'}.to_json
           return
         end
         if request.body.nil?
           response.status = 400
-          response['Content-Type'] = 'application/json'
+          response['Content-Type'] = Rest::MIME_JSON
           response.body = {status: 'error', message: 'Empty request'}.to_json
           return
         end
-        # build script path by removing domain, and adding script folder
+        # build script path by removing domain and adding script folder
         script_file = request.path[@parameters[:root].size..]
         Log.log.debug{"script file=#{script_file}"}
         script_path = File.join(@parameters[:script_folder], script_file)
@@ -47,19 +48,17 @@ module Aspera
         webhook_parameters = JSON.parse(request.body)
         Log.log.debug{Log.dump(:webhook_parameters, webhook_parameters)}
         # env expects only strings
-        environment = webhook_parameters.each_with_object({}) { |(k, v), h| h[k] = v.to_s }
-        post_proc_pid = Process.spawn(environment, [script_path, script_path])
-        Log.log.debug{"pid=#{post_proc_pid}"}
-        raise 'no pid' if post_proc_pid.nil?
-        # "wait" for process to avoid zombie
+        environment = webhook_parameters.each_with_object({}){ |(k, v), h| h[k] = v.to_s}
+        post_proc_pid = Environment.secure_spawn(env: environment, exec: script_path)
         Timeout.timeout(@parameters[:timeout_seconds]) do
+          # "wait" for process to avoid zombie
           Process.wait(post_proc_pid)
           post_proc_pid = nil
         end
         process_status = $CHILD_STATUS
         raise "script #{script_path} failed with code #{process_status.exitstatus}" if !process_status.success? && @parameters[:fail_on_error]
         response.status = 200
-        response.content_type = 'application/json'
+        response.content_type = Rest::MIME_JSON
         response.body = JSON.generate({status: 'success', script: script_path, exit_code: process_status.exitstatus})
         Log.log.debug{'Script executed successfully'}
       rescue => e
@@ -70,7 +69,7 @@ module Aspera
           Log.log.error("Killed process: #{post_proc_pid}")
         end
         response.status = 500
-        response['Content-Type'] = 'application/json'
+        response['Content-Type'] = Rest::MIME_JSON
         response.body = {status: 'error', script: script_path, message: e.message}.to_json
       end
     end

data/lib/aspera/hash_ext.rb

@@ -2,11 +2,11 @@
 
 class ::Hash
   def deep_merge(second)
-    merge(second){|_key, v1, v2|v1.is_a?(Hash) && v2.is_a?(Hash) ? v1.deep_merge(v2) : v2}
+    merge(second){ |_key, v1, v2| v1.is_a?(Hash) && v2.is_a?(Hash) ? v1.deep_merge(v2) : v2}
   end
 
   def deep_merge!(second)
-    merge!(second){|_key, v1, v2|v1.is_a?(Hash) && v2.is_a?(Hash) ? v1.deep_merge!(v2) : v2}
+    merge!(second){ |_key, v1, v2| v1.is_a?(Hash) && v2.is_a?(Hash) ? v1.deep_merge!(v2) : v2}
   end
 
   def deep_do(memory=nil, &block)
@@ -20,17 +20,7 @@ class ::Hash
   end
 end
 
-# in 2.5
-unless Hash.method_defined?(:transform_keys)
-  class Hash
-    def transform_keys
-      raise 'missing block' unless block_given?
-      return each_with_object({}){|(k, v), memo|memo[yield(k)] = v}
-    end
-  end
-end
-
-# rails
+# Exists in Rails
 unless Hash.method_defined?(:symbolize_keys)
   class Hash
     def symbolize_keys
@@ -39,7 +29,7 @@ unless Hash.method_defined?(:symbolize_keys)
   end
 end
 
-# rails
+# Exists in Rails
 unless Hash.method_defined?(:stringify_keys)
   class Hash
     def stringify_keys

data/lib/aspera/json_rpc.rb

@@ -23,7 +23,7 @@ module Aspera
       @request_id = 0
     end
 
-    def respond_to_missing?(sym, include_private = false)
+    def respond_to_missing?(_sym, _include_private = false)
       true
     end