aspera-cli 4.26.2 → 4.27.1

data/lib/aspera/ascp/installation.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 # cspell:ignore protobuf ckpt
+require 'aspera/yaml'
 require 'aspera/environment'
 require 'aspera/data_repository'
 require 'aspera/log'
@@ -46,9 +47,9 @@ module Aspera
       def sdk_locations
         location_url = @transferd_urls
         transferd_locations = UriReader.read(location_url)
-        Log.log.debug{"Retrieving SDK locations from #{location_url}"}
+        Log.log.debug { "Retrieving SDK locations from #{location_url}" }
         begin
-          return YAML.load(transferd_locations)
+          return Yaml.safe_load(transferd_locations)
         rescue Psych::SyntaxError
           raise "Error when parsing yaml data from: #{location_url}"
         end
@@ -60,23 +61,23 @@ module Aspera
       # - "product:PRODUCT_NAME" to use ascp from named product
       # - "product:FIRST" to use ascp from first found product
       def sdk_folder=(ascp_location)
-        Aspera.assert_type(ascp_location, String){'ascp_location'}
+        Aspera.assert_type(ascp_location, String) { 'ascp_location' }
         Aspera.assert(!ascp_location.empty?, 'ascp location cannot be empty: check your config file')
         folder =
           if ascp_location.start_with?(USE_PRODUCT_PREFIX)
             product_name = ascp_location.delete_prefix(USE_PRODUCT_PREFIX)
             if product_name.eql?(FIRST_FOUND)
               pl = installed_products.first
-              raise "No Aspera transfer module or SDK found.\nRefer to the manual or install SDK with command:\nascli conf transferd install" if pl.nil?
+              Aspera.assert(!pl.nil?) { "No Aspera transfer module or SDK found.\nRefer to the manual or install SDK with command:\nascli conf transferd install" }
             else
-              pl = installed_products.find{ |i| i[:name].eql?(product_name)}
-              raise "No such product installed: #{product_name}" if pl.nil?
+              pl = installed_products.find { |i| i[:name].eql?(product_name) }
+              Aspera.assert(!pl.nil?) { "No such product installed: #{product_name}" }
             end
             File.dirname(pl[:ascp_path])
           else
             ascp_location.include?('/ascp') ? File.dirname(ascp_location) : ascp_location
           end
-        Log.log.debug{"ascp_folder=#{folder}"}
+        Log.log.debug { "ascp_folder=#{folder}" }
         Products::Transferd.sdk_directory = folder
         nil
       end
@@ -88,14 +89,14 @@ module Aspera
       # @return [Hash] with key = file name (String), and value = path to file
       def file_paths
         return SDK_FILES.to_h do |v|
-                 [v.to_s, begin
-                   path(v)
-                 rescue Errno::ENOENT => e
-                   e.message.gsub(/.*assertion failed: /, '').gsub(/\): .*/, ')')
-                 rescue => e
-                   e.message
-                 end]
-               end
+          [v.to_s, begin
+            path(v)
+          rescue Errno::ENOENT => e
+            e.message.gsub(/.*assertion failed: /, '').gsub(/\): .*/, ')')
+          rescue => e
+            e.message
+          end]
+        end
       end
 
       # TODO: if using another product than SDK, should use files from there
@@ -106,23 +107,23 @@ module Aspera
 
       # Get path of one resource file of currently activated product
       # keys and certs are generated locally... (they are well known values, arch. independent)
-      # @param k [Symbol] key of the resource file
+      # @param file_type [Symbol] key of the resource file
       # @return [String, nil] Full path to the resource file or nil if not found
-      def path(k)
+      def path(file_type)
         file_is_required = true
-        case k
+        case file_type
         when *EXE_FILES
-          file_is_required = k.eql?(:ascp)
+          file_is_required = file_type.eql?(:ascp)
           file = Products::Transferd.transferd_path
-          file = File.join(File.dirname(file), Environment.instance.exe_file(k.to_s)) unless k.eql?(:transferd)
+          file = File.join(File.dirname(file), Environment.instance.exe_file(file_type.to_s)) unless file_type.eql?(:transferd)
         when :ssh_private_dsa, :ssh_private_rsa
           # assume last 3 letters are type
-          type = k.to_s[-3..].to_sym
-          file = check_or_create_sdk_file("aspera_bypass_#{type}.pem"){DataRepository.instance.item(type)}
+          type = file_type.to_s[-3..].to_sym
+          file = check_or_create_sdk_file("aspera_bypass_#{type}.pem") { DataRepository.instance.item(type) }
         when :aspera_license
-          file = check_or_create_sdk_file('aspera-license'){DataRepository.instance.item(:license)}
+          file = check_or_create_sdk_file('aspera-license') { DataRepository.instance.item(:license) }
         when :aspera_conf
-          file = check_or_create_sdk_file('aspera.conf'){DEFAULT_ASPERA_CONF}
+          file = check_or_create_sdk_file('aspera.conf') { DEFAULT_ASPERA_CONF }
         when :fallback_certificate, :fallback_private_key
           file_key = File.join(Products::Transferd.sdk_directory, 'aspera_fallback_cert_private_key.pem')
           file_cert = File.join(Products::Transferd.sdk_directory, 'aspera_fallback_cert.pem')
@@ -131,30 +132,31 @@ module Aspera
             # create new self signed certificate for http fallback
             private_key = OpenSSL::PKey::RSA.new(4096)
             cert = WebServerSimple.self_signed_cert(private_key)
-            check_or_create_sdk_file('aspera_fallback_cert_private_key.pem', force: true){private_key.to_pem}
-            check_or_create_sdk_file('aspera_fallback_cert.pem', force: true){cert.to_pem}
+            check_or_create_sdk_file('aspera_fallback_cert_private_key.pem', force: true) { private_key.to_pem }
+            check_or_create_sdk_file('aspera_fallback_cert.pem', force: true) { cert.to_pem }
           end
-          file = k.eql?(:fallback_certificate) ? file_cert : file_key
-        else Aspera.error_unexpected_value(k)
+          file = file_type.eql?(:fallback_certificate) ? file_cert : file_key
+        else Aspera.error_unexpected_value(file_type)
         end
         return unless file_is_required || File.exist?(file)
-        Aspera.assert(File.exist?(file), type: Errno::ENOENT){"#{k} not found (#{file})"}
+        Aspera.assert(File.exist?(file), type: Errno::ENOENT) { "#{file_type} not found (#{file})" }
         return file
       end
 
       # default bypass key phrase
-      # @return [String]
+      # @return [String] UUID used as bypass key phrase for SSH certificate
       def ssh_cert_uuid
         return DataRepository.instance.item(:uuid)
       end
 
       # get paths of SSH keys to use for ascp client
-      # @param types [Symbol] types to use
+      # @param types [Symbol] types to use (one of CLIENT_SSH_KEY_OPTIONS)
+      # @return [Array<String>] list of private key file paths
       def aspera_token_ssh_key_paths(types)
         Aspera.assert_values(types, CLIENT_SSH_KEY_OPTIONS)
         return case types
                when :dsa_rsa, :rsa
-                 types.to_s.split('_').map{ |i| Installation.instance.path("ssh_private_#{i}".to_sym)}
+                 types.to_s.split('_').map { |i| Installation.instance.path("ssh_private_#{i}".to_sym) }
                when :per_client
                  Aspera.error_not_implemented
                end
@@ -170,13 +172,11 @@ module Aspera
         Aspera.assert_type(exe_path, String)
         Aspera.assert_type(vers_arg, String)
         return unless File.exist?(exe_path)
-        exe_version = nil
-        cmd_out = %x("#{exe_path}" #{vers_arg})
-        raise "An error occurred when testing #{exe_path}: #{cmd_out}" unless $CHILD_STATUS == 0
+        cmd_out, _err, status = Environment.secure_execute(exe_path, vers_arg, mode: :capture, exception: false)
+        raise "An error occurred when testing #{exe_path}: #{cmd_out}" unless status.success?
         # get version from ascp, only after full extract, as windows requires DLLs (SSL/TLS/etc...)
         m = cmd_out.match(/ version ([0-9.]+)/)
-        exe_version = m[1].gsub(/\.$/, '') unless m.nil?
-        return exe_version
+        m.nil? ? nil : m[1].gsub(/\.$/, '')
       end
 
       # Extract some stings from ascp logs
@@ -234,30 +234,30 @@ module Aspera
         return ascp_data
       end
 
-      # @return the url for download of SDK archive for the given platform and version
+      # @return [String] the url for download of SDK archive for the given platform and version
       def sdk_url_for_platform(platform: nil, version: nil)
         all_locations = sdk_locations
         platform = Environment.instance.architecture if platform.nil?
-        locations = all_locations.select{ |l| l['platform'].eql?(platform)}
-        raise "No SDK for platform: #{platform}, available: #{all_locations.map{ |i| i['platform']}.uniq}" if locations.empty?
-        version = locations.max_by{ |entry| Gem::Version.new(entry['version'])}['version'] if version.nil?
-        info = locations.select{ |entry| entry['version'].eql?(version)}
-        raise "No such version: #{version} for #{platform}" if info.empty?
+        locations = all_locations.select { |l| l['platform'].eql?(platform) }
+        Aspera.assert(!locations.empty?) { "No SDK for platform: #{platform}, available: #{all_locations.map { |i| i['platform'] }.uniq}" }
+        version = locations.max_by { |entry| Gem::Version.new(entry['version']) }['version'] if version.nil?
+        info = locations.select { |entry| entry['version'].eql?(version) }
+        Aspera.assert(!info.empty?) { "No such version: #{version} for #{platform}" }
         return info.first['url']
       end
 
-      # @param sdk_archive_path [String] path to SDK archive
+      # @param url         [String] URL or filename used to detect archive format
+      # @param archive_io  [StringIO] archive content as an in-memory IO stream
       # @yieldparam entry_name [String] File path in archive
       # @yieldparam entry_stream [IO, Gem::Package::TarReader::Entry] Data stream
       # @yieldparam link_target [String, nil] Link target if symlink, nil otherwise
-      def extract_archive_files(sdk_archive_path)
+      def extract_archive_files(url, archive_io)
         Aspera.assert(block_given?, 'missing block')
-        case sdk_archive_path
+        case url
         # Windows and Mac use zip
         when /\.zip$/
           require 'zip'
-          # extract files from archive
-          Zip::File.open(sdk_archive_path) do |zip_file|
+          Zip::File.open_buffer(archive_io) do |zip_file|
             zip_file.each do |entry|
               next if entry.name.end_with?('/')
               entry.get_input_stream do |io|
@@ -269,7 +269,7 @@ module Aspera
         when /\.tar\.gz/
           require 'zlib'
           require 'rubygems/package'
-          Zlib::GzipReader.open(sdk_archive_path) do |gzip|
+          Zlib::GzipReader.wrap(archive_io) do |gzip|
             Gem::Package::TarReader.new(gzip) do |tar|
               tar.each do |entry|
                 next if entry.directory?
@@ -278,19 +278,18 @@ module Aspera
             end
           end
         else
-          raise "unknown archive extension: #{sdk_archive_path}"
+          raise "unknown archive extension: #{url}"
         end
       end
 
-      # Retrieves ascp binary for current system architecture from URL or file
+      # Downloads and extracts the SDK archive for the current platform into +folder+
       # @param folder  [String]      Destination folder path
       # @param url     [nil, String] URL to SDK archive, if nil: default url for version
       # @param version [nil, String] Specific version, if nil: latest version
       # @param backup  [Boolean]     If destination folder exists, then rename
       # @yieldparam entry_name [String] File path from archive
       # @yieldreturn [String, nil] Destination sub folder (end with /) or file, or nil to not extract
-      # @return [Array] name, ascp version (from execution), folder
-      def install_sdk(folder:, url: nil, version: nil, backup: true)
+      def download_sdk(folder:, url: nil, version: nil, backup: true)
         url ||= sdk_url_for_platform(version: version)
         # Rename old install
         if backup && Dir.exist?(folder) && !Dir.empty?(folder)
@@ -303,13 +302,19 @@ module Aspera
         extracted_files = {}
         # Security: Get canonical path of installation directory for boundary checks
         install_boundary = File.realpath(folder)
-        sdk_archive_path = UriReader.read_as_file(url)
-        extract_archive_files(sdk_archive_path) do |entry_name, entry_stream, link_target|
+        archive_io = StringIO.new
+        if UriReader.file?(url)
+          archive_io.write(File.binread(UriReader.file_path(url)))
+        else
+          Rest.new(base_url: url, redirect_max: 3).call(operation: 'GET', save_to: archive_io)
+          archive_io.rewind
+        end
+        extract_archive_files(url, archive_io) do |entry_name, entry_stream, link_target|
           dest_folder = if block_given?
             yield(entry_name)
           else
             # default files to extract directly to main folder if in selected source folders
-            Products::Transferd::RUNTIME_FOLDERS.any?{ |i| entry_name.match?(%r{^[^/]*/#{i}/})} ? '/' : nil
+            Products::Transferd::RUNTIME_FOLDERS.any? { |i| entry_name.match?(%r{^[^/]*/#{i}/}) } ? '/' : nil
           end
           next if dest_folder.nil?
           dest_folder = File.join(folder, dest_folder)
@@ -322,7 +327,7 @@ module Aspera
           # Security: Detect basename collisions that could overwrite symlinks
           file_basename = File.basename(dest_file)
           if extracted_files.key?(file_basename)
-            Log.log.warn{"Rejecting file with duplicate basename: #{entry_name} (basename: #{file_basename}, previous: #{extracted_files[file_basename]})"}
+            Log.log.warn { "Rejecting file with duplicate basename: #{entry_name} (basename: #{file_basename}, previous: #{extracted_files[file_basename]})" }
             next
           end
           extracted_files[file_basename] = entry_name
@@ -330,7 +335,7 @@ module Aspera
           if link_target.nil?
             # Security: Check if destination already exists
             if File.exist?(dest_file)
-              Log.log.warn{"Rejecting write to existing file or link: #{dest_file}"}
+              Log.log.warn { "Rejecting write to existing file or link: #{dest_file}" }
               next
             end
             # Security: Verify the resolved path stays within installation boundary
@@ -340,17 +345,17 @@ module Aspera
               # Check where the file would resolve to (handles existing symlinks in path)
               resolved_dest = File.realpath(File.dirname(dest_file))
               unless resolved_dest.start_with?(install_boundary)
-                Log.log.warn{"Rejecting file outside installation directory: #{dest_file} resolves to #{resolved_dest}"}
+                Log.log.warn { "Rejecting file outside installation directory: #{dest_file} resolves to #{resolved_dest}" }
                 next
               end
             rescue Errno::ENOENT
               # Directory doesn't exist yet, verify the intended path
               unless dest_file.start_with?(folder)
-                Log.log.warn{"Rejecting file with path outside installation directory: #{dest_file}"}
+                Log.log.warn { "Rejecting file with path outside installation directory: #{dest_file}" }
                 next
               end
             end
-            File.open(dest_file, 'wb'){ |output_stream| IO.copy_stream(entry_stream, output_stream)}
+            File.open(dest_file, 'wb') { |output_stream| IO.copy_stream(entry_stream, output_stream) }
           else
             # Security: Validate symlink target stays within installation boundary
             # Resolve the symlink target relative to its location
@@ -364,7 +369,7 @@ module Aspera
             end
             # Check if resolved target would be outside installation directory
             unless resolved_target.start_with?(install_boundary)
-              Log.log.warn{"Rejecting symlink pointing outside installation directory: #{entry_name} -> #{link_target} (resolves to #{resolved_target})"}
+              Log.log.warn { "Rejecting symlink pointing outside installation directory: #{entry_name} -> #{link_target} (resolves to #{resolved_target})" }
               next
             end
             File.symlink(link_target, dest_file)
@@ -372,12 +377,13 @@ module Aspera
         end
       end
 
-      # Retrieve SDK either from specified URL, or specified version from standard location, or latest version
-      # @param url [nil, String] URL
-      # @param version [nil, String] URL
-      def retrieve_sdk(url: nil, version: nil)
+      # Downloads, installs and configures the SDK, returns name, version and install folder
+      # @param url     [nil, String] URL to SDK archive, if nil: default url for version
+      # @param version [nil, String] Specific version, if nil: latest version
+      # @return [Array<String>] sdk name, sdk version, install folder
+      def install_sdk(url: nil, version: nil)
         folder = Products::Transferd.sdk_directory
-        install_sdk(folder: folder, url: url, version: version)
+        download_sdk(folder: folder, url: url, version: version)
         # Ensure necessary files are there, or generate them, restrict file access on SDK executables
         SDK_FILES.each do |file_id_sym|
           file_path = path(file_id_sym)
@@ -420,7 +426,7 @@ module Aspera
       # all executable files from SDK
       EXE_FILES = %i[ascp ascp4 async transferd].freeze
       # IDs of files present in SDK
-      SDK_FILES = %i[ssh_private_dsa ssh_private_rsa aspera_license aspera_conf fallback_certificate fallback_private_key].unshift(*EXE_FILES).freeze
+      SDK_FILES = (EXE_FILES + %i[ssh_private_dsa ssh_private_rsa aspera_license aspera_conf fallback_certificate fallback_private_key]).freeze
       TRANSFERD_ARCHIVE_LOCATION_URL = 'https://ibm.biz/sdk_location'
       # filename for ascp with optional extension (Windows)
       private_constant :DEFAULT_ASPERA_CONF, :EXE_FILES, :SDK_FILES, :TRANSFERD_ARCHIVE_LOCATION_URL
@@ -433,7 +439,7 @@ module Aspera
 
       public
 
-      # @return the list of installed products in format of product_locations_on_current_os
+      # @return [Array<Hash>] the list of installed products in format of product_locations_on_current_os
       def installed_products
         return @found_products unless @found_products.nil?
         # :expected  M app name is taken from the manifest if present, else defaults to this value

data/lib/aspera/ascp/management.rb

@@ -12,7 +12,7 @@ module Aspera
       # https://www.ibm.com/support/pages/error-code-reference-tables
       # mgmtmess.c : as_mgmt_err_is_retryable
       # Note that the fact that an error is retry-able is not internally defined by protocol, it's client-side responsibility
-      # rubocop:disable Layout/FirstHashElementLineBreak
+      # rubocop:disable-next Layout/FirstHashElementLineBreak
       ERRORS = {
         # id   retry-able    mnemo/code                        message                                              additional info
         0  => {r: false, c: 'UNKNOWN',                     m: 'unknown',                                        a: 'unknown'},
@@ -93,7 +93,6 @@ module Aspera
         66 => {r: false, c: 'PEER_REQUIRES_FIPS',          m: 'Peer rejects cipher due to FIPS mode enabled on peer',
                                                                 a: 'Peer rejects cipher due to FIPS mode enabled on peer'}
       }.freeze
-      # rubocop:enable Layout/FirstHashElementLineBreak
       # cspell: disable
       OPERATIONS = %w[
         NOP
@@ -306,8 +305,8 @@ module Aspera
         # @param name [String] Field name
         def field_snake_to_native(name)
           field = name.delete('_')
-          result = PARAMETERS.find{ |w| w.casecmp?(field)}
-          raise "No such field: #{name}" if result.nil?
+          result = PARAMETERS.find { |w| w.casecmp?(field) }
+          Aspera.assert(!result.nil?) { "No such field: #{name}" }
           result
         end
 
@@ -328,7 +327,7 @@ module Aspera
         # @return [String] frame to send on management port
         def command_to_stream(data)
           data
-            .map{ |key, value| "#{field_snake_to_native(key)}: #{value}"}
+            .map { |key, value| "#{field_snake_to_native(key)}: #{value}" }
             .unshift(MGT_HEADER)
             .push(MGT_FRAME_SEPARATOR, '')
             .join("\n")
@@ -353,15 +352,15 @@ module Aspera
           # begin event
           @event_build = {}
         when /^([^:]+): (.*)$/
-          Aspera.assert_type(@event_build, Hash){'mgt port: unexpected line: data without header'}
+          Aspera.assert_type(@event_build, Hash) { 'mgt port: unexpected line: data without header' }
           # event field
           @event_build[Regexp.last_match(1)] = Regexp.last_match(2)
         when MGT_FRAME_SEPARATOR
-          Aspera.assert_type(@event_build, Hash){'mgt port: unexpected line: end frame without header'}
+          Aspera.assert_type(@event_build, Hash) { 'mgt port: unexpected line: end frame without header' }
           @last_event = @event_build
           @event_build = nil
           return @last_event
-        else Aspera.error_unexpected_value(line){'mgt port'}
+        else Aspera.error_unexpected_value(line) { 'mgt port' }
         end
         return
       end

data/lib/aspera/assert.rb

@@ -34,9 +34,9 @@ module Aspera
     end
 
     # Assert that a condition is true, else raise exception
-    # @param assertion [TrueClass, FalseClass]       Must be true
-    # @param info      [String,nil] Fixed message in case assert fails, else use block
-    # @param type      [Exception,Symbol] Exception to raise, or Symbol for Log.log
+    # @param assertion [Boolean] Must be true
+    # @param info [String,nil] Fixed message in case assert fails, else use block
+    # @param type [Exception,Symbol] Exception to raise, or Symbol for Log.log level
     # @yieldreturn [String] A string that describes the problem for complex messages
     # The block is executed in the context of the Aspera module
     def assert(assertion, info = nil, type: AssertError)
@@ -45,7 +45,6 @@ module Aspera
       message = 'assertion failed'
       info = yield if block_given?
       message = type.eql?(AssertError) ? "#{message}: #{info}" : info if info
-      # message = "#{message}: #{caller.find{ |call| !call.start_with?(__FILE__)}}"
       report_error(type, message)
     end
 
@@ -55,7 +54,7 @@ module Aspera
     # @param type    [Exception,Symbol] Exception to raise, or Symbol for Log.log
     # @yieldreturn [String] Additional description to prepend to the error message
     def assert_type(value, *classes, type: AssertError)
-      assert(classes.any?{ |k| value.is_a?(k)}, type: type){"#{"#{yield}: " if block_given?}expecting type #{classes.join(', ')}, but have (#{value.class})#{value.inspect}"}
+      assert(classes.any? { |k| value.is_a?(k) }, type: type) { "#{"#{yield}: " if block_given?}expecting type #{classes.join(', ')}, but have (#{value.class})#{value.inspect}" }
     end
 
     # Assert that all value of array are of the same specified type.
@@ -64,20 +63,20 @@ module Aspera
     # @param type    [Exception,Symbol] Exception to raise, or Symbol for Log.log
     # @yieldreturn [String] Additional description to prepend to the error message
     def assert_array_all(array, klass, type: AssertError)
-      assert_type(array, Array, type: AssertError){'array'}
-      assert(array.all?(klass), type: type){"#{"#{yield}: " if block_given?}expecting all as #{klass}, but have #{array.map(&:class).uniq}"}
+      assert_type(array, Array, type: AssertError) { 'array' }
+      assert(array.all?(klass), type: type) { "#{"#{yield}: " if block_given?}expecting all as #{klass}, but have #{array.map(&:class).uniq}" }
     end
 
     # Assert value is Hash, keys have type, and Values have type
     # @param hash        [Hash]             The hash to check
-    # @param key_class   [Class]            The expected type of keys (or nil)
-    # @param value_class [Class]            The expected type of values (or nil)
+    # @param key_class   [Class]            The expected type of keys (or nil for no check)
+    # @param value_class [Class]            The expected type of values (or nil for no check)
     # @param type        [Exception,Symbol] Exception to raise, or Symbol for Log.log
     # @yieldreturn [String] Additional description to prepend to the error message
     def assert_hash_all(hash, key_class, value_class, type: AssertError)
-      assert_type(hash, Hash, type: AssertError){'hash'}
-      assert_array_all(hash.keys, key_class, type: type){"#{"#{yield}: " if block_given?}keys"} unless key_class.nil?
-      assert_array_all(hash.values, value_class, type: type){"#{"#{yield}: " if block_given?}values"} unless value_class.nil?
+      assert_type(hash, Hash, type: AssertError) { 'hash' }
+      assert_array_all(hash.keys, key_class, type: type) { "#{"#{yield}: " if block_given?}keys" } unless key_class.nil?
+      assert_array_all(hash.values, value_class, type: type) { "#{"#{yield}: " if block_given?}values" } unless value_class.nil?
     end
 
     # Assert that value is one of the given values
@@ -86,7 +85,7 @@ module Aspera
     # @param type   [Exception,Symbol] Exception to raise, or Symbol for Log.log
     # @yieldreturn [String] Additional description to prepend to the error message
     def assert_values(value, values, type: AssertError)
-      assert_type(values, Array, type: AssertError){'values'}
+      assert_type(values, Array, type: AssertError) { 'values' }
       assert(values.include?(value), type: type) do
         val_list = values.inspect
         val_list = "one of #{val_list}" if values.is_a?(Array)

data/lib/aspera/cli/ascp_actions.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require 'aspera/agent/factory'
+require 'aspera/schema/registry'
+require 'aspera/schema/reader'
+
+module Aspera
+  module Cli
+    # Mixin for Config plugin: ASCP / Transferd related actions
+    module AscpActions
+      TRANSFERD_APP_NAME = 'sdk'
+
+      # Mapping from agent symbol to schema key in options.schema.yaml
+      # Agents without dedicated schema (connect, desktop) are omitted.
+      AGENT_SCHEMA_KEY = {
+        direct:    Schema::Registry::DIRECT_AGENT_OPTIONS,
+        node:      Schema::Registry::NODE_AGENT_OPTIONS,
+        httpgw:    Schema::Registry::HTTPGW_AGENT_OPTIONS,
+        transferd: Schema::Registry::TRANSFERD_AGENT_OPTIONS
+      }.freeze
+      private_constant :AGENT_SCHEMA_KEY
+
+      # Set the SDK directory, checking default and former locations
+      def set_sdk_dir
+        sdk_dir = Products::Transferd.sdk_directory rescue nil
+        if sdk_dir.nil?
+          @sdk_default_location = true
+          Log.log.debug('SDK folder is not set, checking default')
+          sdk_dir = self.class.default_app_main_folder(app_name: TRANSFERD_APP_NAME)
+          Log.log.debug { "Checking: #{sdk_dir}" }
+          if !Dir.exist?(sdk_dir)
+            Log.log.debug { "No such folder: #{sdk_dir}" }
+            former_sdk_folder = File.join(self.class.default_app_main_folder(app_name: Info::CMD_NAME), TRANSFERD_APP_NAME)
+            Log.log.debug { "Checking: #{former_sdk_folder}" }
+            sdk_dir = former_sdk_folder if Dir.exist?(former_sdk_folder)
+          end
+          Log.log.debug { "Using: #{sdk_dir}" }
+          Products::Transferd.sdk_directory = sdk_dir
+        end
+      end
+
+      # Install the transfer SDK (ascp + transferd) from a URL or using the default source.
+      # Version defaults to +Info::SDK_VERSION+; pass +LATEST+ as argument to install the latest available version.
+      # @param version [String, nil] version to install; nil means use the default SDK version
+      # @return [Result::Status] installation result message
+      def install_transfer_sdk(version: nil)
+        asked_version = version.nil? ? Info::SDK_VERSION : version
+        asked_version = nil if asked_version.eql?(SpecialValues::LATEST)
+        sdk_url = options.get_option(:sdk_url, mandatory: true)
+        sdk_url = nil if sdk_url.eql?(SpecialValues::DEF)
+        name, ver, folder = Ascp::Installation.instance.install_sdk(url: sdk_url, version: asked_version)
+        return Result::Status.new("Installed #{name} version #{ver} in #{folder}")
+      end
+
+      def action_ascp_show(**)
+        Result::Text.new(Ascp::Installation.instance.path(:ascp))
+      end
+
+      def action_ascp_info(**)
+        data = Ascp::Installation.instance.ascp_info
+        data['ts'] = transfer.user_transfer_spec
+        DataRepository::ELEMENTS.each_with_object(data) { |i, h| h[i.to_s] = DataRepository.instance.item(i) }
+        SecretHider::ADDITIONAL_KEYS_TO_HIDE.concat(DataRepository::ELEMENTS.map(&:to_s))
+        Result::SingleObject.new(data)
+      end
+
+      def action_ascp_install(version: nil, **)
+        install_transfer_sdk(version: version)
+      end
+
+      def action_ascp_spec(**)
+        builder = Schema::Documentation.new(TerminalFormatter, Transfer::Spec::SCHEMA, include_option: true, agent_columns: true).build
+        Result::ObjectList.new(builder.rows, fields: builder.columns)
+      end
+
+      def action_ascp_schema(agent_name: nil, **)
+        schema = Transfer::Spec::SCHEMA.current.merge({'$comment'=>'DO NOT EDIT, this file was generated from the YAML.'})
+        schema['properties'] = schema['properties'].select { |_k, v| CommandLineBuilder.supported_by_agent(agent_name, v) } unless agent_name.nil?
+        schema['properties'] = schema['properties'].sort.to_h
+        Result::SingleObject.new(schema)
+      end
+
+      def action_ascp_errors(**)
+        error_data = []
+        Ascp::Management::ERRORS.each_pair do |code, prop|
+          error_data.push(code: code, mnemonic: prop[:c], retry: prop[:r], info: prop[:a])
+        end
+        Result::ObjectList.new(error_data)
+      end
+
+      def action_ascp_products_list(**)
+        Result::ObjectList.new(Ascp::Installation.instance.installed_products, fields: %w[name app_root])
+      end
+
+      def action_agents_list(**)
+        rows = Agent::Factory::ALL.map do |sym, names|
+          schema_key = AGENT_SCHEMA_KEY[sym]
+          param_names =
+            if schema_key
+              Schema::Registry.instance.reader(schema_key).current['properties']&.keys&.sort&.join(', ') || ''
+            else
+              ''
+            end
+          {
+            'name'       => sym.to_s,
+            'short'      => names[:short].to_s,
+            'parameters' => param_names
+          }
+        end.sort_by { |r| r['name'] }
+        Result::ObjectList.new(rows, fields: %w[name short parameters])
+      end
+
+      def action_agents_show(agent_name:, **)
+        names = Agent::Factory::ALL[agent_name]
+        schema_key = AGENT_SCHEMA_KEY[agent_name]
+        agent_info = {
+          'name'        => agent_name.to_s,
+          'short'       => names[:short].to_s,
+          'description' => schema_key ? Schema::Registry.instance.reader(schema_key).current['description'].to_s : '(no configurable parameters)'
+        }
+        if schema_key
+          properties = Schema::Registry.instance.reader(schema_key).current['properties'] || {}
+          rows = properties.map do |pname, pdef|
+            row = {'parameter' => pname, 'type' => pdef['type'].to_s, 'description' => pdef['description'].to_s}
+            row['required'] = (Schema::Registry.instance.reader(schema_key).current['required'] || []).include?(pname) ? 'yes' : 'no'
+            row['default']  = pdef.key?('default') ? pdef['default'].inspect : ''
+            row['enum']     = pdef.key?('enum')    ? pdef['enum'].join(', ') : ''
+            row
+          end
+          return Result::ObjectList.new(rows, fields: %w[parameter required type default enum description])
+        end
+        Result::SingleObject.new(agent_info)
+      end
+
+      def action_agents_parameters(agent_name:, **)
+        schema_key = AGENT_SCHEMA_KEY[agent_name]
+        return Result::Nothing.new if schema_key.nil?
+        properties = Schema::Registry.instance.reader(schema_key).current['properties'] || {}
+        rows = properties.map do |pname, pdef|
+          {'name' => pname, 'type' => pdef['type'].to_s, 'description' => pdef['description'].to_s}
+        end
+        Result::ObjectList.new(rows, fields: %w[name type description])
+      end
+
+      def action_transferd_install(**)
+        install_transfer_sdk
+      end
+
+      def action_transferd_list(**)
+        sdk_list = Ascp::Installation.instance.sdk_locations
+        Result::ObjectList.new(sdk_list, fields: sdk_list.first.keys - ['url'])
+      end
+    end
+  end
+end