aspera-cli 4.12.0 → 4.14.0

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,80 @@
+# frozen_string_literal: true
+
+# cspell:words Magick MAGICKCORE ITERM mintty winsize termcap
+
+require 'rmagick' # https://rmagick.github.io/index.html
+require 'rainbow'
+require 'io/console'
+module Aspera
+  module Preview
+    # Generates a string that can display an image in a terminal
+    class Terminal
+      # quantum depth is 8 or 16: convert xc: -format "%q" info:
+      # Rainbow only supports 8-bit colors
+      SHIFT_FOR_8_BIT = Magick::MAGICKCORE_QUANTUM_DEPTH - 8
+      ITERM_NAMES = %w[iTerm WezTerm mintty].freeze
+      TERM_ENV_VARS = %w[TERM_PROGRAM LC_TERMINAL].freeze
+      private_constant :SHIFT_FOR_8_BIT, :ITERM_NAMES, :TERM_ENV_VARS
+      class << self
+        def build(blob, reserved_lines: 0, double_precision: true)
+          return iterm_display_image(blob) if iterm_supported?
+          image = Magick::ImageList.new.from_blob(blob)
+          (term_rows, term_columns) = IO.console.winsize
+          term_rows -= reserved_lines
+          # compute scaling to fit terminal
+          fit_term_ratio = [term_rows / image.rows.to_f, term_columns / image.columns.to_f].min
+          # TODO: retrieve terminal font ratio using some termcap ?
+          font_ratio = 1.7
+          height_ratio = double_precision ? 2.0 : 1.0
+          image = image.scale((image.columns * fit_term_ratio * font_ratio).to_i, (image.rows * fit_term_ratio * height_ratio).to_i)
+          # get all pixel colors, adjusted for Rainbow
+          pixel_colors = []
+          image.each_pixel do |pixel, col, row|
+            pixel_rgb = [pixel.red, pixel.green, pixel.blue]
+            pixel_rgb = pixel_rgb.map { |color| color >> SHIFT_FOR_8_BIT } unless SHIFT_FOR_8_BIT.eql?(0)
+            # init 2-dim array
+            pixel_colors[row] ||= []
+            pixel_colors[row][col] = pixel_rgb
+          end
+          # now generate text
+          text_pixels = []
+          pixel_colors.each_with_index do |row_data, row|
+            next if double_precision && row.odd?
+            row_data.each_with_index do |pixel_rgb, col|
+              text_pixels.push("\n") if col.eql?(0) && !row.eql?(0)
+              if double_precision
+                text_pixels.push(Rainbow('▄').background(pixel_rgb).foreground(pixel_colors[row + 1][col]))
+              else
+                text_pixels.push(Rainbow(' ').background(pixel_rgb))
+              end
+            end
+          end
+          return text_pixels.join
+        end
+
+        # display image in iTerm2
+        def iterm_display_image(blob)
+          # image = Magick::ImageList.new.from_blob(blob)
+          arguments = {
+            inline:              1,
+            preserveAspectRatio: 1,
+            size:                blob.length
+            # width:               image.columns,
+            # height:              image.rows
+          }.map { |k, v| "#{k}=#{v}" }.join(';')
+          # \a is BEL, \e is ESC : https://github.com/ruby/ruby/blob/master/doc/syntax/literals.rdoc#label-Strings
+          # https://iterm2.com/documentation-images.html
+          return "\e]1337;File=#{arguments}:#{Base64.encode64(blob)}\a"
+        end
+
+        # @return [Boolean] true if the terminal supports iTerm2 image display
+        def iterm_supported?
+          TERM_ENV_VARS.each do |env_var|
+            return true if ITERM_NAMES.any? { |term| ENV[env_var]&.include?(term) }
+          end
+          false
+        end
+      end # class << self
+    end # class Terminal
+  end # module Preview
+end # module Aspera

data/lib/aspera/preview/utils.rb

@@ -14,12 +14,12 @@ 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
+        # returns string with single quotes suitable for bash if there is any bash meta-character
         def shell_quote(argument)
           return argument unless argument.chars.any?{|c|BASH_SPECIAL_CHARACTERS.include?(c)}
           return "'" + argument.gsub(/'/){|_s| "'\"'\"'"} + "'"
@@ -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}
@@ -55,7 +55,7 @@ module Aspera
             raise "Error: #{command_symb} is not in the PATH"
           end
           unless exit_status.success?
-            Log.log.error{"commandline: #{command}"}
+            Log.log.error{"command line: #{command}"}
             Log.log.error{"Error code: #{exit_status}"}
             Log.log.error{"stdout: #{stdout}"}
             Log.log.error{"stderr: #{stderr}"}
@@ -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] ||= []
@@ -82,17 +82,17 @@ module Aspera
           result = external_command(:ffprobe, [
             '-loglevel', 'error',
             '-show_entries', 'format=duration',
-            '-print_format', 'default=noprint_wrappers=1:nokey=1',
+            '-print_format', 'default=noprint_wrappers=1:nokey=1', # cspell:disable-line
             input_file])
           return result[:stdout].to_f
         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/proxy_auto_config.js

@@ -70,7 +70,7 @@ function shExpMatch(str, shell_expr) {
 }
 function weekdayRange(wd1, wd2, gmt) {
 	var today = new Date();
-	var days = 'SUNMONTUEWEDTHUFRISAT';
+	var days = 'SUNMONTUEWEDTHUFRISAT'; // cspell: disable-line
 	wd1 = wd1.toUpperCase();
 	if (wd2 == undefined)
 		wd2 = wd1;
@@ -138,7 +138,7 @@ function dateRange() {
 			else
 				return false;
 		} else if (typeof arg == 'string') {
-			var months = 'JANFEBMARAPRMAYJUNJULAUGSEPOCTNOVDEC';
+			var months = 'JANFEBMARAPRMAYJUNJULAUGSEPOCTNOVDEC'; // cspell: disable-line
 			arg = arg.toUpperCase();
 			arg = months.indexOf(arg);
 			if (arg == -1)

data/lib/aspera/rest.rb

@@ -38,6 +38,11 @@ module Aspera
 
     ARRAY_PARAMS = '[]'
 
+    private_constant :ARRAY_PARAMS
+
+    # error message when entity not found
+    ENTITY_NOT_FOUND = 'No such'
+
     class << self
       # define accessors
       @@global.each_key do |p|
@@ -50,6 +55,12 @@ module Aspera
 
       def basic_creds(user, pass); return "Basic #{Base64.strict_encode64("#{user}:#{pass}")}"; end
 
+      # used to build a parameter list prefixed with "[]"
+      # @param values [Array] list of values
+      def array_params(values)
+        return [ARRAY_PARAMS].concat(values)
+      end
+
       # build URI from URL and parameters and check it is http or https
       def build_uri(url, params=nil)
         uri = URI.parse(url)
@@ -224,8 +235,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 +298,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']
@@ -336,5 +348,31 @@ module Aspera
     def cancel(subpath)
       return call({operation: 'CANCEL', subpath: subpath, headers: {'Accept' => 'application/json'}})
     end
+
+    # Query by name and returns a single result, else it throws an exception (no or multiple results)
+    # @param subpath path of entity in API
+    # @param search_name name of searched entity
+    # @param options additional search options
+    def lookup_by_name(subpath, search_name, options={})
+      # returns entities whose name contains value (case insensitive)
+      matching_items = read(subpath, options.merge({'q' => CGI.escape(search_name)}))[:data]
+      # API style: {totalcount:, ...} cspell: disable-line
+      # TODO: not generic enough ? move somewhere ? inheritance ?
+      matching_items = matching_items[subpath] if matching_items.is_a?(Hash)
+      raise "Internal error: expecting array, have #{matching_items.class}" unless matching_items.is_a?(Array)
+      case matching_items.length
+      when 1 then return matching_items.first
+      when 0 then raise %Q{#{ENTITY_NOT_FOUND} #{subpath}: "#{search_name}"}
+      else
+        # multiple case insensitive partial matches, try case insensitive full match
+        # (anyway AoC does not allow creation of 2 entities with same case insensitive name)
+        name_matches = matching_items.select{|i|i['name'].casecmp?(search_name)}
+        case name_matches.length
+        when 1 then return name_matches.first
+        when 0 then raise %Q(#{subpath}: multiple case insensitive partial match for: "#{search_name}": #{matching_items.map{|i|i['name']}} but no case insensitive full match. Please be more specific or give exact name.) # rubocop:disable Layout/LineLength
+        else raise "Two entities cannot have the same case insensitive name: #{name_matches.map{|i|i['name']}}"
+        end
+      end
+    end
   end
 end # module Aspera

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

@@ -12,6 +12,7 @@ module Aspera
     # keys in hash that contain secrets
     KEY_SECRETS = %w[password secret passphrase _key apikey crn token].freeze
     ALL_SECRETS = [ASCP_ENV_SECRETS, KEY_SECRETS].flatten.freeze
+    FALSE_POSITIVES = [/^access_key$/].freeze
     # regex that define named captures :begin and :end
     REGEX_LOG_REPLACES = [
       # CLI manager get/set options
@@ -35,20 +36,24 @@ 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
 
       def secret?(keyword, value)
         keyword = keyword.to_s if keyword.is_a?(Symbol)
         # only Strings can be secrets, not booleans, or hash, arrays
-        keyword.is_a?(String) && ALL_SECRETS.any?{|kw|keyword.include?(kw)} && value.is_a?(String)
+        return false unless keyword.is_a?(String) && value.is_a?(String)
+        # those are not secrets
+        return false if FALSE_POSITIVES.any?{|f|f.match?(keyword)}
+        # check if keyword (name) contains an element that designate it as a secret
+        ALL_SECRETS.any?{|kw|keyword.include?(kw)}
       end
 
       def deep_remove_secret(obj, is_name_value: false)

data/lib/aspera/ssh.rb

@@ -44,7 +44,7 @@ module Aspera
             end
             raise error_message
           end
-          # send command to SSH channel (execute)
+          # send command to SSH channel (execute) cspell: disable-next-line
           channel.send('cexe'.reverse, cmd){|_ch, _success|channel.send_data(input) unless input.nil?}
         end
         # wait for channel to finish (command exit)

data/lib/aspera/sync.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# cspell:words logdir
+
 require 'aspera/command_line_builder'
 require 'aspera/fasp/installation'
 require 'json'
@@ -8,6 +10,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 +47,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 +69,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 +83,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 +115,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 +146,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 +154,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 +168,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 )