aspera-cli 4.27.2 → 4.27.4

data/lib/aspera/node_simulator.rb

@@ -1,344 +0,0 @@
-# frozen_string_literal: true
-
-require 'aspera/assert'
-require 'aspera/ascp/installation'
-require 'aspera/agent/direct'
-require 'aspera/log'
-require 'webrick'
-require 'json'
-
-module Aspera
-  class NodeSimulator
-    def initialize
-      @agent = Agent::Direct.new(management_cb: ->(event) { process_event(event) })
-      @sessions = {}
-    end
-
-    def start(ts)
-      @agent.start_transfer(ts)
-    end
-
-    def all_sessions
-      @agent.sessions.map { |session| session[:job_id] }.uniq.each.map { |job_id| job_to_transfer(job_id) }
-    end
-
-    # status: ('waiting', 'partially_completed', 'unknown', 'waiting(read error)',] 'running', 'completed', 'failed'
-    def job_to_transfer(job_id)
-      jobs = @agent.sessions_by_job(job_id)
-      ts = nil
-      sessions = jobs.map do |j|
-        ts ||= j[:ts]
-        {
-          id:                    j[:id],
-          client_node_id:        '',
-          server_node_id:        '2bbdcc39-f789-4d47-8163-6767fc14f421',
-          client_ip_address:     '192.168.0.100',
-          server_ip_address:     '5.10.114.4',
-          status:                'running',
-          retry_timeout:         3600,
-          retry_count:           0,
-          start_time_usec:       1701094040000000,
-          end_time_usec:         nil,
-          elapsed_usec:          405312,
-          bytes_transferred:     26,
-          bytes_written:         26,
-          bytes_lost:            0,
-          files_completed:       1,
-          directories_completed: 0,
-          target_rate_kbps:      500000,
-          min_rate_kbps:         0,
-          calc_rate_kbps:        9900,
-          network_delay_usec:    40000,
-          avg_rate_kbps:         0.51,
-          error_code:            0,
-          error_desc:            '',
-          source_statistics:     {
-            args_scan_attempted:  1,
-            args_scan_completed:  1,
-            paths_scan_attempted: 1,
-            paths_scan_failed:    0,
-            paths_scan_skipped:   0,
-            paths_scan_excluded:  0,
-            dirs_scan_completed:  0,
-            files_scan_completed: 1,
-            dirs_xfer_attempted:  0,
-            dirs_xfer_fail:       0,
-            files_xfer_attempted: 1,
-            files_xfer_fail:      0,
-            files_xfer_noxfer:    0
-          },
-          precalc:               {
-            enabled:              true,
-            status:               'ready',
-            bytes_expected:       0,
-            directories_expected: 0,
-            files_expected:       0,
-            files_excluded:       0,
-            files_special:        0,
-            files_failed:         1
-          }
-        }
-      end
-      ts ||= {}
-      result = {
-        id:                    job_id,
-        status:                'running',
-        start_spec:            ts,
-        sessions:              sessions,
-        bytes_transferred:     26,
-        bytes_written:         26,
-        bytes_lost:            0,
-        avg_rate_kbps:         0.51,
-        files_completed:       1,
-        files_skipped:         0,
-        directories_completed: 0,
-        start_time_usec:       1701094040000000,
-        end_time_usec:         1701094040405312,
-        elapsed_usec:          405312,
-        error_code:            0,
-        error_desc:            '',
-        precalc:               {
-          status:               'ready',
-          bytes_expected:       0,
-          files_expected:       0,
-          directories_expected: 0,
-          files_special:        0,
-          files_failed:         1
-        },
-        files:                 [{
-          id:              'd1b5c112-82b75425-860745fc-93851671-64541bdd',
-          path:            '/workspaces/45071/packages/bYA_ilq73g.asp-package/contents/data_file.bin',
-          start_time_usec: 1701094040000000,
-          elapsed_usec:    105616,
-          end_time_usec:   1701094040001355,
-          status:          'completed',
-          error_code:      0,
-          error_desc:      '',
-          size:            26,
-          type:            'file',
-          checksum_type:   'none',
-          checksum:        nil,
-          start_byte:      0,
-          bytes_written:   26,
-          session_id:      'bafc72b8-366c-4501-8095-47208183d6b8'
-        }]
-      }
-      Log.dump(:job, result, level: :trace2)
-      return result
-    end
-
-    # Process event from management port
-    def process_event(event)
-      # Code duplicated on purpose, as implementation goes, blocks will be replaced
-      case event['Type']
-      when 'NOP' then Aspera.Log.debug { "event not managed: #{event['Type']}" }
-      # rubocop:disable Lint/DuplicateBranch
-      when 'START' then Aspera.Log.debug { "event not managed: #{event['Type']}" }
-      when 'QUERY' then Aspera.Log.debug { "event not managed: #{event['Type']}" }
-      when 'QUERYRSP' then Aspera.Log.debug { "event not managed: #{event['Type']}" }
-      when 'STATS' then Aspera.Log.debug { "event not managed: #{event['Type']}" }
-      when 'STOP' then Aspera.Log.debug { "event not managed: #{event['Type']}" }
-      when 'ERROR' then Aspera.Log.debug { "event not managed: #{event['Type']}" }
-      when 'CANCEL' then Aspera.Log.debug { "event not managed: #{event['Type']}" }
-      when 'DONE' then Aspera.Log.debug { "event not managed: #{event['Type']}" }
-      when 'RATE' then Aspera.Log.debug { "event not managed: #{event['Type']}" }
-      when 'FILEERROR' then Aspera.Log.debug { "event not managed: #{event['Type']}" }
-      when 'SESSION' then Aspera.Log.debug { "event not managed: #{event['Type']}" }
-      when 'NOTIFICATION' then Aspera.Log.debug { "event not managed: #{event['Type']}" }
-      when 'INIT' then Aspera.Log.debug { "event not managed: #{event['Type']}" }
-      when 'VLINK' then Aspera.Log.debug { "event not managed: #{event['Type']}" }
-      when 'PUT' then Aspera.Log.debug { "event not managed: #{event['Type']}" }
-      when 'WRITE' then Aspera.Log.debug { "event not managed: #{event['Type']}" }
-      when 'CLOSE' then Aspera.Log.debug { "event not managed: #{event['Type']}" }
-      when 'SKIP' then Aspera.Log.debug { "event not managed: #{event['Type']}" }
-      when 'ARGSTOP' then Aspera.Log.debug { "event not managed: #{event['Type']}" }
-      # rubocop:enable Lint/DuplicateBranch
-      else Aspera.error_unreachable_line
-      end
-    end
-  end
-
-  # this class answers the Faspex /send API and creates a package on Aspera on Cloud
-  # a new instance is created for each request
-  class NodeSimulatorServlet < WEBrick::HTTPServlet::AbstractServlet
-    PATH_TRANSFERS = '/ops/transfers'
-    PATH_ONE_TRANSFER = %r{/ops/transfers/(.+)$}
-    PATH_BROWSE = '/files/browse'
-    # @param credentials [Hash]
-    # @param simulator   [NodeSimulator]
-    def initialize(server, credentials, simulator)
-      super(server)
-      @credentials = credentials
-      @simulator = simulator
-      # Resolve once at startup; default to current working directory
-      @browse_root = File.realpath(credentials[:browse_root] || Dir.pwd)
-    end
-
-    require 'json'
-    require 'time'
-
-    def folder_to_structure(folder_path)
-      # Resolve and confine to browse_root (prevents path traversal via client-supplied path)
-      resolved = File.realpath(folder_path)
-      Aspera.assert(resolved.start_with?("#{@browse_root}/") || resolved.eql?(@browse_root)) { 'Browse path traversal attempt detected' }
-      Aspera.assert(Dir.exist?(resolved)) { "Path does not exist or is not a directory: #{resolved}" }
-      folder_path = resolved
-
-      # Build self structure
-      folder_stat = File.stat(folder_path)
-      structure = {
-        'self'  => {
-          'path'        => folder_path,
-          'basename'    => File.basename(folder_path),
-          'type'        => 'directory',
-          'size'        => folder_stat.size,
-          'mtime'       => folder_stat.mtime.utc.iso8601,
-          'permissions' => [
-            {'name' => 'view'},
-            {'name' => 'edit'},
-            {'name' => 'delete'}
-          ]
-        },
-        'items' => []
-      }
-
-      # Iterate over folder contents
-      Dir.foreach(folder_path) do |entry|
-        next if entry == '.' || entry == '..' # Skip current and parent directory
-
-        item_path = File.join(folder_path, entry)
-        item_type = File.ftype(item_path) rescue 'unknown' # Get the type of file
-        item_stat = File.lstat(item_path) # Use lstat to handle symbolic links correctly
-
-        item = {
-          'path'        => item_path,
-          'basename'    => entry,
-          'type'        => item_type,
-          'size'        => item_stat.size,
-          'mtime'       => item_stat.mtime.utc.iso8601,
-          'permissions' => [
-            {'name' => 'view'},
-            {'name' => 'edit'},
-            {'name' => 'delete'}
-          ]
-        }
-
-        # Add additional details for specific types
-        case item_type
-        when 'file'
-          item['partial_file'] = false
-        when 'link'
-          item['target'] = File.readlink(item_path) rescue nil # Add the target of the symlink
-        when 'unknown'
-          item['note'] = 'File type could not be determined'
-        end
-
-        structure['items'] << item
-      end
-
-      structure
-    end
-
-    def do_POST(request, response)
-      case request.path
-      when PATH_TRANSFERS
-        job_id = @simulator.start(JSON.parse(request.body))
-        sleep(0.5)
-        set_json_response(request, response, @simulator.job_to_transfer(job_id))
-      when PATH_BROWSE
-        req = JSON.parse(request.body)
-        # req['count']
-        set_json_response(request, response, folder_to_structure(req['path'] || @browse_root))
-      else
-        set_json_response(request, response, [{error: 'Bad request'}], code: 400)
-      end
-    end
-
-    def do_GET(request, response)
-      case request.path
-      when '/info'
-        info = Ascp::Installation.instance.ascp_info
-        set_json_response(request, response, {
-          application:                           'node',
-          current_time:                          Time.now.utc.iso8601(0),
-          version:                               info['sdk_ascp_version'].gsub(/ .*$/, ''),
-          license_expiration_date:               info['expiration_date'],
-          license_max_rate:                      info['maximum_bandwidth'],
-          os:                                    %x(uname -srv).chomp,
-          aej_status:                            'disconnected',
-          async_reporting:                       'no',
-          transfer_activity_reporting:           'no',
-          transfer_user:                         'xfer',
-          docroot:                               'file:////data/aoc/eudemo-sedemo',
-          node_id:                               '2bbdcc39-f789-4d47-8163-6767fc14f421',
-          cluster_id:                            '6dae2844-d1a9-47a5-916d-9b3eac3ea466',
-          acls:                                  ['impersonation'],
-          access_key_configuration_capabilities: {
-            transfer: %w[
-              cipher
-              policy
-              target_rate_cap_kbps
-              target_rate_kbps
-              preserve_timestamps
-              content_protection_secret
-              aggressiveness
-              token_encryption_key
-              byok_enabled
-              bandwidth_flow_network_rc_module
-              file_checksum_type
-            ],
-            server:   %w[
-              activity_event_logging
-              activity_file_event_logging
-              recursive_counts
-              aej_logging
-              wss_enabled
-              activity_transfer_ignore_skipped_files
-              activity_files_max
-              access_key_credentials_encryption_type
-              discovery
-              auto_delete
-              allow
-              deny
-            ]
-          },
-          capabilities:                          [
-            {name:  'sync', value: true},
-            {name:  'watchfolder', value: true},
-            {name:  'symbolic_links', value: true},
-            {name:  'move_file', value: true},
-            {name:  'move_directory', value: true},
-            {name:  'filelock', value: false},
-            {name:  'ssh_fingerprint', value: false},
-            {name:  'aej_version', value: '1.0'},
-            {name:  'page', value: true},
-            {name:  'file_id_version', value: '2.0'},
-            {name:  'auto_delete', value: false}
-          ],
-          settings:                              [
-            {name:  'content_protection_required', value: false},
-            {name:  'content_protection_strong_pass_required', value: false},
-            {name:  'filelock_restriction', value: 'none'},
-            {name:  'ssh_fingerprint', value: nil},
-            {name:  'wss_enabled', value: false},
-            {name:  'wss_port', value: 443}
-          ]
-        })
-      when PATH_TRANSFERS
-        set_json_response(request, response, @simulator.all_sessions)
-      when PATH_ONE_TRANSFER
-        job_id = request.path.match(PATH_ONE_TRANSFER)[1]
-        set_json_response(request, response, @simulator.job_to_transfer(job_id))
-      else
-        set_json_response(request, response, [{error: 'Unknown request'}], code: 400)
-      end
-    end
-
-    def set_json_response(request, response, json, code: 200)
-      response.status = code
-      response['Content-Type'] = Mime::JSON
-      response.body = json.to_json
-      Log.log.trace1 { Log.obj_dump("response for #{request.request_method} #{request.path}", json) }
-    end
-  end
-end

data/lib/aspera/preview/options.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-# cspell:ignore reencode conv transframes pauseframes
-
-module Aspera
-  module Preview
-    # generator options. Used as parameter to preview generator object.
-    # also settable by command line.
-    class Options
-      # types of generation for video files
-      VIDEO_CONVERSION_METHODS = %i[reencode blend clips].freeze
-      VIDEO_THUMBNAIL_METHODS = %i[fixed animated].freeze
-      # methods for office document conversion
-      OFFICE_CONVERSION_METHODS = %i[soffice unoconv].freeze
-      # options used in generator
-      # for scaling see: https://trac.ffmpeg.org/wiki/Scaling
-      # iw/ih : input width or height
-      # -x : keep aspect ratio, having value a multiple of x
-      DESCRIPTIONS = [
-        {name: :max_size,             default: 1 << 24,            description: 'maximum size (in bytes) of preview file'},
-        {name: :thumb_vid_scale,      default: '-1:min(ih,100)',   description: 'png: video: size (ffmpeg scale argument)'},
-        {name: :thumb_vid_fraction,   default: 0.1,                description: 'png: video: time percent position of snapshot'},
-        {name: :thumb_img_size,       default: 800,                description: 'png: non-video: height (and width)'},
-        {name: :thumb_text_font,      default: 'Courier',          description: 'png: plaintext: font for text rendering: `magick identify -list font`'},
-        {name: :office_conversion,    default: :soffice,           description: 'office: method for office document conversion', values: OFFICE_CONVERSION_METHODS},
-        {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_scale,          default: 'min(iw,360):-2',   description: 'mp4: all: video scale (ffmpeg scale argument)'},
-        {name: :video_start_sec,      default: 10,                 description: 'mp4: all: start offset (seconds) of video preview'},
-        {name: :video_codec,          default: nil,                description: 'mp4: reencode: video codec for ffmpeg (e.g. libx264, h264_videotoolbox, h264_nvenc), default: auto-detect'},
-        {name: :reencode_ffmpeg,      default: {},                 description: 'mp4: reencode: options to ffmpeg, keys: `in`, `out`'},
-        {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'},
-        {name: :blend_fps,            default: 15,                 description: 'mp4: blend: frame per second'},
-        {name: :clips_count,          default: 5,                  description: 'mp4: clips: number of clips'},
-        {name: :clips_length,         default: 5,                  description: 'mp4: clips: length in seconds of each clips'}
-      ].freeze
-      # add accessors
-      DESCRIPTIONS.each do |opt|
-        attr_accessor opt[:name]
-      end
-    end
-  end
-end

data/lib/aspera/rest_call_error.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module Aspera
-  # raised on error after REST call
-  class RestCallError < StandardError
-    def request
-      @context[:request]
-    end
-
-    def response
-      @context[:response]
-    end
-
-    def data
-      @context[:data]
-    end
-
-    # @param context [Hash,String] with keys :messages, :request, :response, :data
-    def initialize(context)
-      context = {messages: [context]} if context.is_a?(String)
-      @context = context
-      super(@context[:messages].join("\n"))
-    end
-  end
-end

data/lib/aspera/rest_error_analyzer.rb

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-require 'aspera/rest_call_error'
-require 'aspera/log'
-require 'singleton'
-require 'net/http'
-
-module Aspera
-  # analyze error codes returned by REST calls and raise ruby exception
-  #
-  # @!method self.instance
-  #   Returns the singleton instance of RestErrorAnalyzer
-  #   @return [RestErrorAnalyzer] the singleton instance
-  class RestErrorAnalyzer
-    include Singleton
-
-    attr_accessor :log_file
-
-    # the singleton object is registered with application specific handlers
-    def initialize
-      # list of handlers
-      @error_handlers = []
-      @log_file = nil
-      add_handler('Type Generic') do |type, context|
-        if !context[:response].code.start_with?('2')
-          # add generic information
-          RestErrorAnalyzer.add_error(context, type, "#{context[:request]['host']} #{context[:response].code} #{context[:response].message}")
-        end
-      end
-    end
-
-    # Use this method to analyze a EST result and raise an exception
-    # Analyzes REST call response and raises a RestCallError exception
-    # if HTTP result code is not 2XX
-    # @param req  [Net::HTTPRequest]  the HTTP request
-    # @param data [Object]            the parsed response body
-    # @param http [Net::HTTPResponse] the raw HTTP response
-    def raise_on_error(req, data, http)
-      Log.log.debug { "raise_on_error #{req.method} #{req.path} #{http.code}" }
-      context = {
-        messages: [],
-        request:  req,
-        response: http,
-        data:     data
-      }
-      # multiple error messages can be found
-      # analyze errors from provided handlers
-      # note that there can be an error even if code is 2XX
-      @error_handlers.each do |handler|
-        handler[:block].call(handler[:name], context)
-      rescue StandardError => e
-        Log.log.error { "ERROR in handler:\n#{e.message}\n#{e.backtrace}" }
-      end
-      raise RestCallError, context unless context[:messages].empty?
-    end
-
-    # Add a new error handler (done at application initialization)
-    # @param name  [String] name of error handler (for logs)
-    # @param block [Proc]   processing of response: takes two parameters: `name`, `context`
-    # name is the one provided here
-    # context is built in method raise_on_error
-    def add_handler(name, &block)
-      @error_handlers.unshift({name: name, block: block})
-      nil
-    end
-
-    # Add a simple error handler
-    # Check that key exists and is string under specified path (hash)
-    # Adds other keys as secondary information
-    # @param name   [String]  name of error handler (for logs)
-    # @param always [Boolean] if true, always add error message, even if response code is 2XX
-    # @param path   [Array]   path to error message in response
-    def add_simple_handler(name:, always: false, path:)
-      path.freeze
-      add_handler(name) do |type, context|
-        if context[:data].is_a?(Hash) && (!context[:response].code.start_with?('2') || always)
-          # Log.log.debug{"simple_handler: #{type} #{path} #{path.last}"}
-          # dig and find hash containing error message
-          error_struct = path.length.eql?(1) ? context[:data] : context[:data].dig(*path[0..-2])
-          # Log.log.debug{"found: #{error_struct.class} #{error_struct}"}
-          if error_struct.is_a?(Hash) && error_struct[path.last].is_a?(String)
-            RestErrorAnalyzer.add_error(context, type, error_struct[path.last])
-            error_struct.each do |k, v|
-              next if k.eql?(path.last)
-              RestErrorAnalyzer.add_error(context, "#{type}(sub)", "#{k}: #{v}") if [String, Integer].include?(v.class)
-            end
-          end
-        end
-      end
-    end
-
-    class << self
-      # Used by handler to add an error description to list of errors
-      # For logging and tracing : collect error descriptions (create file to activate)
-      # @param context [Hash]   the result context, provided to handler
-      # @param type    [String] type of exception, for logging purpose
-      # @param message [String] one error message  to add to list
-      def add_error(context, type, message)
-        context[:messages].push(message)
-        Log.log.trace1 { "Found error: #{type}: #{message}" }
-        log_file = instance.log_file
-        # log error for further analysis (file must exist to activate)
-        return if log_file.nil? || !File.exist?(log_file)
-        File.open(log_file, 'a+') do |f|
-          f.write("\n=#{type}=====\n#{context[:request].method} #{context[:request].path}\n#{context[:response].code}\n" \
-            "#{JSON.generate(context[:data])}\n#{context[:messages].join("\n")}")
-        end
-      end
-    end
-  end
-end

data/lib/aspera/rest_errors_aspera.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-require 'aspera/rest_error_analyzer'
-require 'aspera/log'
-
-module Aspera
-  # REST error handlers for various Aspera REST APIs
-  class RestErrorsAspera
-    class << self
-      # handlers should probably be defined by plugins for modularity
-      def register_handlers
-        Log.log.debug('registering Aspera REST error handlers')
-        # Faspex 4: both user_message and internal_message, and code 200
-        # example: missing meta data on package creation
-        RestErrorAnalyzer.instance.add_simple_handler(name: 'Type 1: error:user_message', path: %w[error user_message], always: true)
-        RestErrorAnalyzer.instance.add_simple_handler(name: 'Type 2: error:description', path: %w[error description])
-        RestErrorAnalyzer.instance.add_simple_handler(name: 'Type 3: error:internal_message', path: %w[error internal_message])
-        RestErrorAnalyzer.instance.add_simple_handler(name: 'Type 5', path: ['error_description'])
-        RestErrorAnalyzer.instance.add_simple_handler(name: 'Type 6', path: ['message'])
-        RestErrorAnalyzer.instance.add_simple_handler(name: 'Type 6', path: ['failure'], always: true)
-        # AoC Automation
-        RestErrorAnalyzer.instance.add_simple_handler(name: 'AoC Automation', path: ['error'])
-        RestErrorAnalyzer.instance.add_handler('Type 7: errors[]') do |type, context|
-          next unless context[:data].is_a?(Hash) && context[:data]['errors'].is_a?(Hash)
-          # special for Shares: false positive ? (update global transfer_settings)
-          next if context[:data].key?('min_connect_version')
-          context[:data]['errors'].each do |k, v|
-            RestErrorAnalyzer.add_error(context, type, "#{k}: #{v}")
-          end
-        end
-        # call to upload_setup and download_setup of node api
-        RestErrorAnalyzer.instance.add_handler('T8:node: *_setup') do |type, context|
-          next unless context[:data].is_a?(Hash)
-          d_t_s = context[:data]['transfer_specs']
-          next unless d_t_s.is_a?(Array)
-          d_t_s.each do |res|
-            r_err = res.dig(*%w[transfer_spec error]) || res['error']
-            next unless r_err.is_a?(Hash)
-            RestErrorAnalyzer.add_error(context, type, r_err.values.join(': '))
-          end
-        end
-        RestErrorAnalyzer.instance.add_simple_handler(name: 'T9:IBM cloud IAM', path: ['errorMessage'])
-        RestErrorAnalyzer.instance.add_simple_handler(name: 'T10:faspex v4', path: ['user_message'])
-        RestErrorAnalyzer.instance.add_handler('Orchestrator') do |type, context|
-          next if context[:response].code.start_with?('2')
-          data = context[:data]
-          next unless data.is_a?(Hash)
-          work_order = data['work_order']
-          next unless work_order.is_a?(Hash)
-          RestErrorAnalyzer.add_error(context, type, work_order['statusDetails'])
-          data['missing_parameters']&.each do |param|
-            RestErrorAnalyzer.add_error(context, type, "missing parameter: #{param}")
-          end
-        end
-      end
-    end
-  end
-end