aspera-cli 4.12.0 → 4.13.0

data/lib/aspera/fasp/parameters.rb

@@ -38,8 +38,9 @@ module Aspera
           return @param_description_cache
         end
 
+        # @param to_text [bool] replace HTML entities with text equivalent
         # @return a table suitable to display in manual
-        def man_table(to_text: true)
+        def man_table
           result = []
           description.each do |name, options|
             param = {name: name, type: [options[:accepted_types]].flatten.join(','), description: options[:desc]}
@@ -70,10 +71,17 @@ module Aspera
             if options.key?(:enum)
               param[:description] += "\nAllowed values: #{options[:enum].join(', ')}"
             end
-            param[:description] = param[:description].gsub('/', '/') if to_text
+            # replace "solidus" HTML entity with its text value
+            param[:description] = param[:description].gsub('/', '\\')
             result.push(param)
           end
-          return result
+          return result.sort do |a, b|
+            if a[:name].start_with?('EX_').eql?(b[:name].start_with?('EX_'))
+              a[:name] <=> b[:name]
+            else
+              b[:name] <=> a[:name]
+            end
+          end
         end
 
         # special encoding methods used in YAML (key: :convert)

data/lib/aspera/fasp/parameters.yaml

@@ -559,7 +559,8 @@ remove_empty_source_directory:
   :cli:
     :type: :opt_without_arg
 EX_at_rest_password:
-  :desc: "DEPRECATED: Prefer to use standard parameter: content_protection_password"
+  :desc: Content protection password
+  :deprecation: "Use standard spec parameter: content_protection_password"
   :agents:
   - :direct
   :cli:
@@ -703,6 +704,7 @@ EX_file_pair_list:
     :switch: "--file-pair-list"
 EX_ascp_args:
   :desc: Add native command line arguments to ascp
+  :deprecation: Use parameter ascp_args in option transfer_info
   :accepted_types: :array
   :agents:
   - :direct

data/lib/aspera/fasp/transfer_spec.rb

@@ -15,7 +15,9 @@ module Aspera
         'ssh_port'    => SSH_PORT,
         'fasp_port'   => UDP_PORT
       }.freeze
-      # define constants for enums of parameters: <paramater>_<enum>, e.g. CIPHER_AES_128
+      # reserved tag for Aspera
+      TAG_RESERVED = 'aspera'
+      # define constants for enums of parameters: <parameter>_<enum>, e.g. CIPHER_AES_128
       Aspera::Fasp::Parameters.description.each do |k, v|
         next unless v[:enum].is_a?(Array)
         v[:enum].each do |enum|

data/lib/aspera/faspex_gw.rb

@@ -84,6 +84,7 @@ module Aspera
           response['Content-Type'] = 'application/json'
           response.body = {error: e.message}.to_json
           Log.log.error(e.message)
+          Log.log.debug{e.backtrace.join("\n")}
         end
       else
         response.status = 400

data/lib/aspera/faspex_postproc.rb

@@ -19,7 +19,7 @@ module Aspera
       @parameters[:fail_on_error] ||= false
       @parameters[:timeout_seconds] ||= 60
       super(server)
-      Log.log.debug{"Faspex4PostProcServlet initialized"}
+      Log.log.debug{'Faspex4PostProcServlet initialized'}
     end
 
     def do_POST(request, response)
@@ -39,7 +39,7 @@ module Aspera
           return
         end
         # build script path by removing domain, and adding script folder
-        script_file = request.path[@parameters[:root].size .. ]
+        script_file = request.path[@parameters[:root].size..]
         Log.log.debug{"script file=#{script_file}"}
         script_path = File.join(@parameters[:script_folder], script_file)
         Log.log.debug{"script=#{script_path}"}

data/lib/aspera/node.rb

@@ -40,7 +40,9 @@ module Aspera
       end
     end
 
-    REQUIRED_APP_INFO_FIELDS = %i[node_info app api workspace_info].freeze
+    # fields in @app_info
+    REQUIRED_APP_INFO_FIELDS = %i[api app node_info workspace_id workspace_name].freeze
+    # methods of @app_info[:api]
     REQUIRED_APP_API_METHODS = %i[node_api_from add_ts_tags].freeze
     private_constant :REQUIRED_APP_INFO_FIELDS, :REQUIRED_APP_API_METHODS
 
@@ -71,8 +73,13 @@ module Aspera
 
     # @returns [Aspera::Node] a Node or nil
     def node_id_to_node(node_id)
-      return self if !@app_info.nil? && @app_info[:node_info]['id'].eql?(node_id)
-      return @app_info[:api].node_api_from(node_id: node_id, workspace_info: @app_info[workspace_info]) unless @app_info.nil?
+      if !@app_info.nil?
+        return self if node_id.eql?(@app_info[:node_info]['id'])
+        return @app_info[:api].node_api_from(
+          node_id: node_id,
+          workspace_id: @app_info[:workspace_id],
+          workspace_name: @app_info[:workspace_name])
+      end
       Log.log.warn{"cannot resolve link with node id #{node_id}"}
       return nil
     end
@@ -216,7 +223,7 @@ module Aspera
         'direction' => direction,
         'token'     => ak_token,
         'tags'      => {
-          'aspera' => {
+          Fasp::TransferSpec::TAG_RESERVED => {
             'node' => {
               'access_key' => ak_name,
               'file_id'    => file_id

data/lib/aspera/oauth.rb

@@ -87,6 +87,7 @@ module Aspera
       # @param lambda_create called to create token
       # @param id_create called to generate unique id for token, for cache
       def register_token_creator(id, lambda_create, id_create)
+        Log.log.debug{"registering token creator #{id}"}
         raise 'ERROR: requites Symbol and 2 lambdas' unless id.is_a?(Symbol) && lambda_create.is_a?(Proc) && id_create.is_a?(Proc)
         @create_handlers[id] = lambda_create
         @id_handlers[id] = id_create
@@ -94,7 +95,7 @@ module Aspera
 
       # @return one of the registered creators for the given create type
       def token_creator(id)
-        raise "token grant method unknown: #{id}/#{id.class}" unless @create_handlers.key?(id)
+        raise "token grant method unknown: '#{id}' (#{id.class})" unless @create_handlers.key?(id)
         @create_handlers[id]
       end
 
@@ -272,7 +273,7 @@ module Aspera
 
       # an API was already called, but failed, we need to regenerate or refresh
       if use_refresh_token
-        if token_data.is_a?(Hash) && token_data.key?('refresh_token')
+        if token_data.is_a?(Hash) && token_data.key?('refresh_token') && !token_data['refresh_token'].eql?('not_supported')
           # save possible refresh token, before deleting the cache
           refresh_token = token_data['refresh_token']
         end

data/lib/aspera/preview/file_types.rb

@@ -12,6 +12,7 @@ module Aspera
       CONVERSION_TYPES = %i[image office pdf plaintext video].freeze
 
       # define how files are processed based on mime type
+      # spellchecker:disable
       SUPPORTED_MIME_TYPES = {
         'application/json'                                                          => :plaintext,
         'application/mac-binhex40'                                                  => :office,
@@ -267,6 +268,7 @@ module Aspera
         'ycbcra'       => :image,
         'yuv'          => :image,
         'zabw'         => :office}.freeze
+      # spellchecker:enable
 
       private_constant :SUPPORTED_MIME_TYPES, :SUPPORTED_EXTENSIONS
 
@@ -301,12 +303,12 @@ module Aspera
       def conversion_type(filepath, mimetype)
         Log.log.debug{"conversion_type(#{filepath},m=#{mimetype},t=#{@use_mimemagic})"}
         # 1- get type from provided mime type, using local mapping
-        conv_type = SUPPORTED_MIME_TYPES[mimetype] if !mimetype.nil?
+        conversion_type = SUPPORTED_MIME_TYPES[mimetype] if !mimetype.nil?
         # 2- else, from computed mime type (if available)
-        if conv_type.nil? && @use_mimemagic
+        if conversion_type.nil? && @use_mimemagic
           detected_mime = mime_from_file(filepath)
           if !detected_mime.nil?
-            conv_type = SUPPORTED_MIME_TYPES[detected_mime]
+            conversion_type = SUPPORTED_MIME_TYPES[detected_mime]
             if !mimetype.nil?
               if mimetype.eql?(detected_mime)
                 Log.log.debug('matching mime type per magic number')
@@ -319,9 +321,9 @@ module Aspera
         end
         # 3- else, from extensions, using local mapping
         extension = File.extname(filepath.downcase)[1..-1]
-        conv_type = SUPPORTED_EXTENSIONS[extension] if conv_type.nil?
-        Log.log.debug{"conversion_type(#{extension}): #{conv_type.class.name} [#{conv_type}]"}
-        return conv_type
+        conversion_type = SUPPORTED_EXTENSIONS[extension] if conversion_type.nil?
+        Log.log.debug{"conversion_type(#{extension}): #{conversion_type.class.name} [#{conversion_type}]"}
+        return conversion_type
       end
     end
   end

data/lib/aspera/preview/generator.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
+# ffmpeg options:
+# spellchecker:ignore pauseframes libx264 trunc bufsize muxer apng libmp3lame maxrate posterize movflags faststart
+# spellchecker:ignore palettegen paletteuse pointsize bordercolor repage lanczos
+
 require 'open3'
 require 'aspera/preview/options'
 require 'aspera/preview/utils'
@@ -12,6 +16,8 @@ module Aspera
       # values for preview_format : output format
       PREVIEW_FORMATS = %i[png mp4].freeze
 
+      FFMPEG_OPTIONS_LIST = %w[in out].freeze
+
       # CLI needs to know conversion type to know if need skip it
       attr_reader :conversion_type
 
@@ -22,7 +28,6 @@ module Aspera
       # supported preview type is one of Preview::PREVIEW_FORMATS
       # the resulting preview file type is taken from destination file extension.
       # conversion methods are provided by private methods: convert_<conversion_type>_to_<preview_format>
-      # (combi = combination of source file type and destination format)
       #   -> conversion_type is one of FileTypes::CONVERSION_TYPES
       #   -> preview_format is one of Generator::PREVIEW_FORMATS
       # the conversion video->mp4 is implemented in methods: convert_video_to_mp4_using_<video_conversion>
@@ -70,10 +75,10 @@ module Aspera
           # check that generated size does not exceed maximum
           result_size = File.size(@destination_file_path)
           if result_size > @options.max_size
-            Log.log.warn{"preview size exceeds maximum #{result_size} > #{@options.max_size}"}
+            Log.log.warn{"preview size exceeds maximum allowed #{result_size} > #{@options.max_size}"}
           end
         rescue StandardError => e
-          Log.log.error{"Ignoging: #{e.message}"}
+          Log.log.error{"Ignoring: #{e.message}"}
           Log.log.debug(e.backtrace.join("\n").red)
           FileUtils.cp(File.expand_path(@preview_format_symb.eql?(:mp4) ? 'video_error.png' : 'image_error.png', File.dirname(__FILE__)), @destination_file_path)
         ensure
@@ -102,11 +107,11 @@ module Aspera
       def convert_video_to_mp4_using_blend
         p_duration = Utils.video_get_duration(@source_file_path)
         p_start_offset = @options.video_start_sec.to_i
-        p_keyframecount = @options.blend_keyframes.to_i
+        p_key_frame_count = @options.blend_keyframes.to_i
         last_keyframe = nil
         current_index = 1
-        1.upto(p_keyframecount) do |i|
-          offset_seconds = get_offset(p_duration, p_start_offset, p_keyframecount, i)
+        1.upto(p_key_frame_count) do |i|
+          offset_seconds = get_offset(p_duration, p_start_offset, p_key_frame_count, i)
           Utils.video_dump_frame(@source_file_path, offset_seconds, @options.video_scale, this_tmpdir, current_index)
           Utils.video_dupe_frame(this_tmpdir, current_index, @options.blend_pauseframes)
           Utils.video_blend_frames(this_tmpdir, last_keyframe, current_index) unless last_keyframe.nil?
@@ -133,17 +138,17 @@ module Aspera
         File.open(filelist, 'w+') do |f|
           1.upto(@options.clips_count.to_i) do |i|
             offset_seconds = get_offset(p_duration, @options.video_start_sec.to_i, @options.clips_count.to_i, i)
-            tmpfilename = format('clip%04d.mp4', i)
+            tmp_file_name = format('clip%04d.mp4', i)
             Utils.ffmpeg(
               in_f: @source_file_path,
               in_p: ['-ss', offset_seconds * 0.9],
-              out_f: File.join(this_tmpdir, tmpfilename),
+              out_f: File.join(this_tmpdir, tmp_file_name),
               out_p: [
                 '-ss', offset_seconds * 0.1,
                 '-t', @options.clips_length,
                 '-filter:v', "scale=#{@options.video_scale}",
                 '-codec:a', 'libmp3lame'])
-            f.puts("file '#{tmpfilename}'")
+            f.puts("file '#{tmp_file_name}'")
           end
         end
         # concat clips
@@ -154,12 +159,19 @@ module Aspera
           out_p: ['-codec', 'copy'])
       end
 
-      # do a simple reencoding
+      # do a simple re-encoding
       def convert_video_to_mp4_using_reencode
+        options = @options.reencode_ffmpeg
+        raise 'reencode_ffmpeg must be a Hash' unless options.is_a?(Hash)
+        options.each do |k, v|
+          raise "Key not supported: #{k}. Use keys: #{FFMPEG_OPTIONS_LIST.join(',')}" unless FFMPEG_OPTIONS_LIST.include?(k)
+          raise "Value for #{k} must be Array" unless v.is_a?(Array)
+        end
         Utils.ffmpeg(
           in_f: @source_file_path,
+          in_p: options['in'] || ['-ss', @options.video_start_sec.to_i * 0.9],
           out_f: @destination_file_path,
-          out_p: [
+          out_p: options['out'] || [
             '-t', '60',
             '-codec:v', 'libx264',
             '-profile:v', 'high',

data/lib/aspera/preview/options.rb

@@ -20,8 +20,9 @@ module Aspera
         { name: :thumb_text_font,      default: 'Courier',          description: 'png: plaintext: font to render text with imagemagick convert (identify -list font)'},
         { name: :video_conversion,     default: :reencode,          description: 'mp4: method for preview generation', values: VIDEO_CONVERSION_METHODS },
         { name: :video_png_conv,       default: :fixed,             description: 'mp4: method for thumbnail generation', values: VIDEO_THUMBNAIL_METHODS },
-        { name: :video_start_sec,      default: 10,                 description: 'mp4: start offset (seconds) of video preview' },
-        { name: :video_scale,          default: "'min(iw,360)':-2", description: 'mp4: video scale (ffmpeg)' },
+        { name: :video_scale,          default: "'min(iw,360)':-2", description: 'mp4: all: video scale (ffmpeg)' },
+        { name: :video_start_sec,      default: 10,                 description: 'mp4: all: start offset (seconds) of video preview' },
+        { name: :reencode_ffmpeg,      default: {},                 description: 'mp4: reencode: options to ffmpeg' },
         { name: :blend_keyframes,      default: 30,                 description: 'mp4: blend: # key frames' },
         { name: :blend_pauseframes,    default: 3,                  description: 'mp4: blend: # pause frames' },
         { name: :blend_transframes,    default: 5,                  description: 'mp4: blend: # transition blend frames' },

data/lib/aspera/preview/terminal.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'rmagick' # https://rmagick.github.io/index.html
+require 'rainbow'
+require 'io/console'
+module Aspera
+  module Preview
+    # function conversion_type returns one of the types: CONVERSION_TYPES
+    class Terminal
+      class << self
+        def build(blob, reserved_lines: 0)
+          # TODO: retrieve terminal ratio using
+          font_ratio = 1.7
+          (term_rows, term_columns) = IO.console.winsize
+          term_rows -= reserved_lines
+          image = Magick::ImageList.new.from_blob(blob)
+          chosen_factor = [term_rows / image.rows.to_f, term_columns / image.columns.to_f].min
+          image = image.scale((image.columns * chosen_factor * font_ratio).to_i, (image.rows * chosen_factor).to_i)
+          text_pixels = []
+          image.each_pixel do |pixel, col, row|
+            text_pixels.push("\n") if col.eql?(0) && !row.eql?(0)
+            pixel_rgb = [pixel.red, pixel.green, pixel.blue].map do |color|
+              # quantum depth is 8 or 16: convert xc: -format "%q" info:
+              # Rainbow only supports 8-bit colors
+              color >> (Magick::MAGICKCORE_QUANTUM_DEPTH - 8)
+            end
+            text_pixels.push(Rainbow(' ').background(pixel_rgb))
+          end
+          return text_pixels.join
+        end
+    end # class << self
+    end # class Terminal
+  end # module Preview
+end # module Aspera

data/lib/aspera/preview/utils.rb

@@ -14,9 +14,9 @@ module Aspera
       # shell exit code when command is not found
       BASH_EXIT_NOT_FOUND = 127
       # external binaries used
-      EXPERNAL_TOOLS = %i[ffmpeg ffprobe convert composite optipng unoconv].freeze
-      TMPFMT = 'img%04d.jpg'
-      private_constant :BASH_SPECIAL_CHARACTERS, :BASH_EXIT_NOT_FOUND, :EXPERNAL_TOOLS, :TMPFMT
+      EXTERNAL_TOOLS = %i[ffmpeg ffprobe convert composite optipng unoconv].freeze
+      TEMP_FORMAT = 'img%04d.jpg'
+      private_constant :BASH_SPECIAL_CHARACTERS, :BASH_EXIT_NOT_FOUND, :EXTERNAL_TOOLS, :TEMP_FORMAT
 
       class << self
         # returns string with single quotes suitable for bash if there is any bash metacharacter
@@ -27,7 +27,7 @@ module Aspera
 
         # check that external tools can be executed
         def check_tools(skip_types=[])
-          tools_to_check = EXPERNAL_TOOLS.dup
+          tools_to_check = EXTERNAL_TOOLS.dup
           tools_to_check.delete(:unoconv) if skip_types.include?(:office)
           # Check for binaries
           tools_to_check.each do |command_symb|
@@ -39,7 +39,7 @@ module Aspera
         # one could use "system", but we would need to redirect stdout/err
         # @return true if su
         def external_command(command_symb, command_args)
-          raise "unexpected command #{command_symb}" unless EXPERNAL_TOOLS.include?(command_symb)
+          raise "unexpected command #{command_symb}" unless EXTERNAL_TOOLS.include?(command_symb)
           # build command line, and quote special characters
           command = command_args.clone.unshift(command_symb).map{|i| shell_quote(i.to_s)}.join(' ')
           Log.log.debug{"cmd=#{command}".blue}
@@ -69,7 +69,7 @@ module Aspera
           # input_file,input_args,output_file,output_args
           a[:gl_p] ||= [
             '-y', # overwrite output without asking
-            '-loglevel', 'error' # show only errors and up]
+            '-loglevel', 'error' # show only errors and up
           ]
           a[:in_p] ||= []
           a[:out_p] ||= []
@@ -88,11 +88,11 @@ module Aspera
         end
 
         def ffmpeg_fmt(temp_folder)
-          return File.join(temp_folder, TMPFMT)
+          return File.join(temp_folder, TEMP_FORMAT)
         end
 
         def get_tmp_num_filepath(temp_folder, file_number)
-          return File.join(temp_folder, format(TMPFMT, file_number))
+          return File.join(temp_folder, format(TEMP_FORMAT, file_number))
         end
 
         def video_dupe_frame(temp_folder, index, count)

data/lib/aspera/rest.rb

@@ -224,8 +224,9 @@ module Aspera
       begin
         # we try the call, and will retry only if oauth, as we can, first with refresh, and then re-auth if refresh is bad
         oauth_tries ||= 2
-        tries_remain_redirect ||= call_data[:redirect_max].nil? ? 0 : call_data[:redirect_max].to_i
-        Log.log.debug('send request')
+        # initialize with number of initial retries allowed, nil gives zero
+        tries_remain_redirect = call_data[:redirect_max].to_i if tries_remain_redirect.nil?
+        Log.log.debug("send request (retries=#{tries_remain_redirect})")
         # make http request (pipelined)
         http_session.request(req) do |response|
           result[:http] = response
@@ -286,8 +287,8 @@ module Aspera
           Log.log.debug{"using new token=#{call_data[:headers]['Authorization']}"}
           retry unless (oauth_tries -= 1).zero?
         end # if oauth
-        # moved ?
-        if e.response.is_a?(Net::HTTPRedirection) && tries_remain_redirect.positive?
+        # redirect ? (any code beginning with 3)
+        if tries_remain_redirect.positive? && e.response.is_a?(Net::HTTPRedirection)
           tries_remain_redirect -= 1
           current_uri = URI.parse(call_data[:base_url])
           new_url = e.response['location']

data/lib/aspera/rest_call_error.rb

@@ -5,7 +5,9 @@ module Aspera
   class RestCallError < StandardError
     attr_accessor :request, :response
 
-    # @param http response
+    # @param req HTTP Request object
+    # @param resp HTTP Response object
+    # @param msg Error message
     def initialize(req, resp, msg)
       @request = req
       @response = resp

data/lib/aspera/secret_hider.rb

@@ -35,13 +35,13 @@ module Aspera
       def log_formatter(original_formatter)
         original_formatter ||= Logger::Formatter.new
         # NOTE: that @log_secrets may be set AFTER this init is done, so it's done at runtime
-        return lambda do |severity, datetime, progname, msg|
+        return lambda do |severity, date_time, program_name, msg|
           if msg.is_a?(String) && !@log_secrets
-            REGEX_LOG_REPLACES.each do |regx|
-              msg = msg.gsub(regx){"#{Regexp.last_match(:begin)}#{HIDDEN_PASSWORD}#{Regexp.last_match(:end)}"}
+            REGEX_LOG_REPLACES.each do |reg_ex|
+              msg = msg.gsub(reg_ex){"#{Regexp.last_match(:begin)}#{HIDDEN_PASSWORD}#{Regexp.last_match(:end)}"}
             end
           end
-          original_formatter.call(severity, datetime, progname, msg)
+          original_formatter.call(severity, date_time, program_name, msg)
         end
       end
 

data/lib/aspera/sync.rb

@@ -8,6 +8,13 @@ require 'base64'
 module Aspera
   # builds command line arg for async
   class Sync
+    # default is push
+    DIRECTIONS = %i[push pull bidi].freeze
+    DIRECTION_TO_REQUEST_TYPE = {
+      push: :sync_upload,
+      pull: :sync_download,
+      bidi: :sync
+    }.freeze
     PARAMS_VX_INSTANCE =
       {
         'alt_logdir'          => { cli: { type: :opt_with_arg}, accepted_types: :string},
@@ -38,7 +45,7 @@ module Aspera
         'cooloff'                    => { cli: { type: :opt_with_arg}, accepted_types: :int},
         'pending_max'                => { cli: { type: :opt_with_arg}, accepted_types: :int},
         'scan_intensity'             => { cli: { type: :opt_with_arg}, accepted_types: :string},
-        'cipher'                     => { cli: { type: :opt_with_arg}, accepted_types: :string, ts: true},
+        'cipher'                     => { cli: { type: :opt_with_arg, convert: 'Aspera::Fasp::Parameters.convert_remove_hyphen'}, accepted_types: :string, ts: true},
         'transfer_threads'           => { cli: { type: :opt_with_arg}, accepted_types: :int},
         'preserve_time'              => { cli: { type: :opt_without_arg}, ts: :preserve_times},
         'preserve_access_time'       => { cli: { type: :opt_without_arg}, ts: nil},
@@ -60,7 +67,7 @@ module Aspera
     PARAMS_VX_KEYS = %w[instance sessions].freeze
 
     # new API
-    TS_TO_PARAMS = {
+    TS_TO_PARAMS_V2 = {
       'remote_host'     => 'remote.host',
       'remote_user'     => 'remote.user',
       'remote_password' => 'remote.pass',
@@ -74,14 +81,27 @@ module Aspera
 
     ASYNC_EXECUTABLE = 'async'
 
-    private_constant :PARAMS_VX_INSTANCE, :PARAMS_VX_SESSION, :PARAMS_VX_KEYS, :ASYNC_EXECUTABLE
+    private_constant :PARAMS_VX_INSTANCE, :PARAMS_VX_SESSION, :PARAMS_VX_KEYS, :ASYNC_EXECUTABLE, :TS_TO_PARAMS_V2
+
+    attr_reader :env_args
 
-    class << self
-      def update_parameters_with_transfer_spec(sync_params, transfer_spec)
-        if sync_params.key?('local')
+    # @param sync_params [Hash] sync parameters, old or new format
+    # @param node_sync [Object|nil]
+    def initialize(sync_params, node_sync)
+      raise StandardError, 'parameter must be Hash' unless sync_params.is_a?(Hash)
+      raise 'node_sync misses method transfer_spec' unless node_sync.nil? || node_sync.respond_to?(:transfer_spec)
+      @env_args = {
+        args: [],
+        env:  {}
+      }
+      if sync_params.key?('local')
+        # async native JSON format (v2)
+        raise StandardError, 'remote must be Hash' unless sync_params['remote'].is_a?(Hash)
+        unless node_sync.nil?
+          transfer_spec = node_sync.transfer_spec(sync_params['direction'], sync_params['local']['path'], sync_params['remote']['path'])
           # async native JSON format
           raise StandardError, 'local must be Hash' unless sync_params['local'].is_a?(Hash)
-          TS_TO_PARAMS.each do |ts_param, sy_path|
+          TS_TO_PARAMS_V2.each do |ts_param, sy_path|
             next unless transfer_spec.key?(ts_param)
             sy_dig = sy_path.split('.')
             param = sy_dig.pop
@@ -93,38 +113,23 @@ module Aspera
           sync_params['remote']['connect_mode'] ||= sync_params['remote'].key?('ws_port') ? 'ws' : 'ssh'
           sync_params['remote']['private_key_paths'] ||= Fasp::Installation.instance.bypass_keys if transfer_spec.key?('token')
           sync_params['remote']['path'] ||= '/' if transfer_spec.dig(*%w[tags aspera node file_id])
-        elsif sync_params.key?('sessions')
+        end
+        @env_args[:args] = ["--conf64=#{Base64.strict_encode64(JSON.generate(sync_params))}"]
+      elsif sync_params.key?('sessions')
+        # ascli JSON format (v1)
+        unless node_sync.nil?
           sync_params['sessions'].each do |session|
-            PARAMS_VX_SESSION.each do |async_param, behaviour|
-              if behaviour.key?(:ts)
-                tspec_param = behaviour[:ts].is_a?(TrueClass) ? async_param : behaviour[:ts].to_s
+            transfer_spec = node_sync.transfer_spec(session['direction'], session['local_dir'], session['remote_dir'])
+            PARAMS_VX_SESSION.each do |async_param, behavior|
+              if behavior.key?(:ts)
+                tspec_param = behavior[:ts].is_a?(TrueClass) ? async_param : behavior[:ts].to_s
                 session[async_param] ||= transfer_spec[tspec_param] if transfer_spec.key?(tspec_param)
               end
             end
             session['private_key_paths'] = Fasp::Installation.instance.bypass_keys if transfer_spec.key?('token')
             session['remote_dir'] = '/' if transfer_spec.dig(*%w[tags aspera node file_id])
           end
-        else
-          raise 'At least one of `local` or `sessions` must be present in async parameters'
         end
-        Log.dump(:sync, sync_params)
-      end
-    end
-
-    attr_reader :env_args
-
-    def initialize(sync_params)
-      raise StandardError, 'parameter must be Hash' unless sync_params.is_a?(Hash)
-      @env_args = {
-        args: [],
-        env:  {}
-      }
-      if sync_params.key?('local')
-        # async native JSON format
-        raise StandardError, 'remote must be Hash' unless sync_params['remote'].is_a?(Hash)
-        @env_args[:args] = "--conf64=#{Base64.strict_encode64(JSON.generate(sync_params))}"
-      elsif sync_params.key?('sessions')
-        # ascli JSON format
         raise StandardError, "Only 'sessions', and optionally 'instance' keys are allowed" unless
           sync_params.keys.push('instance').uniq.sort.eql?(PARAMS_VX_KEYS)
         raise StandardError, 'sessions key must be Array' unless sync_params['sessions'].is_a?(Array)
@@ -139,7 +144,7 @@ module Aspera
 
         sync_params['sessions'].each do |session_params|
           raise StandardError, 'sessions must contain hashes' unless session_params.is_a?(Hash)
-          raise StandardError, 'session must contain at leat name' unless session_params.key?('name')
+          raise StandardError, 'session must contain at least name' unless session_params.key?('name')
           session_builder = Aspera::CommandLineBuilder.new(session_params, PARAMS_VX_SESSION)
           session_builder.process_params
           session_builder.add_env_args(@env_args[:env], @env_args[:args])
@@ -147,6 +152,7 @@ module Aspera
       else
         raise 'At least one of `local` or `sessions` must be present in async parameters'
       end
+      Log.dump(:sync, sync_params)
     end
 
     def start
@@ -160,7 +166,7 @@ module Aspera
       else raise 'internal error: unspecified case'
       end
     end
-  end
+  end # end Sync
 
   class SyncAdmin
     ASYNC_ADMIN_EXECUTABLE = 'asyncadmin'

data/lib/aspera/web_server_simple.rb

@@ -8,24 +8,26 @@ require 'openssl'
 module Aspera
   class WebServerSimple < WEBrick::HTTPServer
     CERT_PARAMETERS = %i[key cert chain].freeze
-    # generates and adds self signed cert to provided webrick options
-    def self.fill_self_signed_cert(cert, key)
-      cert.subject = cert.issuer = OpenSSL::X509::Name.parse('/C=FR/O=Test/OU=Test/CN=Test')
-      cert.not_before = Time.now
-      cert.not_after = Time.now + 365 * 24 * 60 * 60
-      cert.public_key = key.public_key
-      cert.serial = 0x0
-      cert.version = 2
-      ef = OpenSSL::X509::ExtensionFactory.new
-      ef.issuer_certificate = cert
-      ef.subject_certificate = cert
-      cert.extensions = [
-        ef.create_extension('basicConstraints', 'CA:TRUE', true),
-        ef.create_extension('subjectKeyIdentifier', 'hash')
-        # ef.create_extension('keyUsage', 'cRLSign,keyCertSign', true),
-      ]
-      cert.add_extension(ef.create_extension('authorityKeyIdentifier', 'keyid:always,issuer:always'))
-      cert.sign(key, OpenSSL::Digest.new('SHA256'))
+    class << self
+      # generates and adds self signed cert to provided webrick options
+      def fill_self_signed_cert(cert, key)
+        cert.subject = cert.issuer = OpenSSL::X509::Name.parse('/C=FR/O=Test/OU=Test/CN=Test')
+        cert.not_before = Time.now
+        cert.not_after = Time.now + 365 * 24 * 60 * 60
+        cert.public_key = key.public_key
+        cert.serial = 0x0
+        cert.version = 2
+        ef = OpenSSL::X509::ExtensionFactory.new
+        ef.issuer_certificate = cert
+        ef.subject_certificate = cert
+        cert.extensions = [
+          ef.create_extension('basicConstraints', 'CA:TRUE', true),
+          ef.create_extension('subjectKeyIdentifier', 'hash')
+          # ef.create_extension('keyUsage', 'cRLSign,keyCertSign', true),
+        ]
+        cert.add_extension(ef.create_extension('authorityKeyIdentifier', 'keyid:always,issuer:always'))
+        cert.sign(key, OpenSSL::Digest.new('SHA256'))
+      end
     end
 
     # @param uri [URI]
@@ -66,6 +68,8 @@ module Aspera
       end
       # self signed certificate generates characters on STDERR, see create_self_signed_cert in webrick/ssl.rb
       Log.capture_stderr { super(webrick_options) }
+      # kill -USR1 for graceful shutdown
+      Kernel.trap('USR1') { shutdown }
     end
 
     # log web server access ( option AccessLog )