aspera-cli 4.27.2 → 4.27.4

data/lib/aspera/cli/ascp_actions.rb

@@ -21,26 +21,31 @@ module Aspera
       private_constant :AGENT_SCHEMA_KEY
 
       # Set the SDK directory, checking default and former locations
+      # If a product is selected for `ascp`, the SDK directory is still needed (keys, conf, transferd)
       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}" }
+        sdk_folder = options.get_option(:sdk_folder)
+        product_selected = Ascp::Installation.product_selector?(sdk_folder)
+        return unless sdk_folder.nil? || product_selected
+        @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}" }
+        if product_selected
           Products::Transferd.sdk_directory = sdk_dir
+        else
+          options.set_option(:sdk_folder, sdk_dir, source: :default)
         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.
+      # 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)
@@ -52,27 +57,14 @@ module Aspera
         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(**)
+        SecretHider.instance.add_secret_keys(DataRepository::ELEMENTS)
         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?
@@ -88,10 +80,6 @@ module Aspera
         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]
@@ -141,15 +129,6 @@ module Aspera
         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

data/lib/aspera/cli/async_transfer_store.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'aspera/log'
+require 'aspera/secret_hider'
 require 'json'
 require 'securerandom'
 
@@ -10,7 +11,7 @@ module Aspera
     #
     # Each entry is a JSON document identified by a `job_id` (UUID generated by ascli).
     # The underlying storage uses PersistencyFolder with the category prefix
-    # +CATEGORY+ so all async-transfer files are grouped together and can be
+    # `CATEGORY` so all async-transfer files are grouped together and can be
     # garbage-collected independently.
     #
     # Schema of a stored entry:
@@ -59,14 +60,14 @@ module Aspera
       end
 
       # Persist (create or update) an async transfer entry.
-      # Keys whose name starts with '_' are in-process references (e.g. '_agent_ref')
-      # and are intentionally excluded from the JSON serialization — at every nesting level.
+      # Keys whose name starts with '_' are in-process references (e.g. '_agent_ref'), and secrets (e.g. agent `password`)
+      # are not written on disk: they are intentionally excluded from the JSON serialization — at every nesting level.
       # @param job_id [String] the ascli-generated UUID
       # @param data   [Hash]   fields to store (will be JSON-serialised)
       def write(job_id, data)
         Aspera.assert_type(job_id, String) { 'job_id' }
         Aspera.assert_type(data, Hash) { 'data' }
-        @persistency.put(store_key(job_id), JSON.generate(strip_internal_keys(data)))
+        @persistency.put(store_key(job_id), JSON.generate(persistable(data)))
         nil
       end
 
@@ -81,7 +82,7 @@ module Aspera
       end
 
       # List all async transfer entries.
-      # @return [Array<Hash>] each entry includes the +job_id+ field
+      # @return [Array<Hash>] each entry includes the `job_id` field
       def list
         @persistency.current_items(CATEGORY).map do |key, raw|
           data = JSON.parse(raw)
@@ -105,17 +106,17 @@ module Aspera
         "#{CATEGORY}#{job_id}"
       end
 
-      # Recursively remove keys whose name starts with '_' from a Hash.
-      # Such keys hold in-process Ruby object references (e.g. '_agent_ref') that
-      # cannot be serialized to JSON and must never reach the file system.
-      def strip_internal_keys(value)
+      # Recursively remove from a Hash the keys that must never reach the file system:
+      # - keys whose name starts with '_': in-process Ruby object references (e.g. '_agent_ref') that cannot be serialized to JSON
+      # - secrets (e.g. 'password'): taken from current options when the transfer is queried
+      def persistable(value)
         case value
         when Hash
           value.each_with_object({}) do |(k, v), h|
-            h[k] = strip_internal_keys(v) unless k.to_s.start_with?('_')
+            h[k] = persistable(v) unless k.to_s.start_with?('_') || SecretHider.instance.secret?(k, v)
           end
         when Array
-          value.map { |v| strip_internal_keys(v) }
+          value.map { |v| persistable(v) }
         else
           value
         end

data/lib/aspera/cli/bootstrapper.rb

@@ -31,8 +31,8 @@ module Aspera
     #   - populate context.persistency, context.presets, context.http_config, context.progress_bar
     #   - register plugin lookup folders
     #   - register @preset / @vault extended-value handlers
-    #   - configure global singletons: RestParameters, OAuth::Factory, SSL, Transfer::Parameters,
-    #     RestErrorAnalyzer
+    #   - configure global singletons: Rest::Parameters, OAuth::Factory, SSL, Transfer::Parameters,
+    #     Rest::ErrorAnalyzer
     #   - set up the PAC proxy executor (option :fpac)
     class Bootstrapper
       # Folder name inside $HOME for all Aspera tool data (~/.aspera)
@@ -88,16 +88,13 @@ module Aspera
         setup_rest_and_transfer_runtime
       end
 
-      # Public accessor used as option handler for :config_file
-      attr_accessor :config_file_option
-
       private
 
       # Declare + parse :home option: sets context.main_folder
       def setup_main_folder
         @context.options.declare(
           :home, description: 'Home folder for tool',
-          handler: {o: @context, m: :main_folder},
+          on_set: @context.method(:main_folder=),
           default: default_app_main_folder(app_name: Info::CMD_NAME)
         )
         @context.options.parse_options!
@@ -115,11 +112,10 @@ module Aspera
       def setup_config_file
         @context.options.declare(
           :config_file, description: 'Path to YAML file with preset configuration',
-          handler: {o: self, m: :config_file_option},
           default: File.join(@context.main_folder, DEFAULT_CONFIG_FILENAME)
         )
         @context.options.parse_options!
-        @context.presets = PresetManager.new(config_file: @config_file_option)
+        @context.presets = PresetManager.new(config_file: @context.options.get_option(:config_file))
         @context.http_config = Http.new
       end
 
@@ -143,9 +139,11 @@ module Aspera
 
       # Declare + parse :progress_bar: sets context.progress_bar
       def setup_progress_bar
-        @context.options.declare(:progress_bar, description: 'Display progress bar', allowed: Type::BOOLEAN, default: Environment.terminal?)
+        @context.options.declare(:progress_bar, description: 'Display progress bar', allowed: Type::BOOLEAN, default: $stderr.tty?)
         @context.options.parse_options!
         @context.progress_bar = TransferProgress.new if @context.options.get_option(:progress_bar)
+        # Log lines do not overwrite the progress bar
+        Log.instance.status_line = @context.progress_bar
       end
 
       # Declare + parse :fpac / :proxy_credentials: sets up PAC executor
@@ -165,18 +163,18 @@ module Aspera
         end
       end
 
-      # Configure global singletons: RestParameters, SSL, Transfer, RestErrorAnalyzer.
+      # Configure global singletons: Rest::Parameters, SSL, Transfer, Rest::ErrorAnalyzer.
       # OAuth persist_mgr is NOT set here: it depends on :cache_tokens which is parsed later
       # by Config#initialize. Runner sets it after Config.new.
       def setup_rest_and_transfer_runtime
-        RestParameters.instance.user_agent    = Info::CMD_NAME
-        RestParameters.instance.progress_bar  = @context.progress_bar
-        RestParameters.instance.session_cb    = ->(http_session) { @context.http_config.update_session(http_session) }
-        RestParameters.instance.spinner_cb    = ->(title = nil, action: :spin) { @context.formatter.long_operation(title, action: action) }
+        Rest::Parameters.instance.user_agent    = Info::CMD_NAME
+        Rest::Parameters.instance.progress_bar  = @context.progress_bar
+        Rest::Parameters.instance.session_cb    = ->(http_session) { @context.http_config.update_session(http_session) }
+        Rest::Parameters.instance.spinner_cb    = ->(title = nil, action: :spin) { @context.formatter.long_operation(title, action: action) }
         OAuth::Web.additional_info = "#{Info::CMD_NAME} v#{Cli::VERSION}"
         Transfer::Parameters.file_list_folder = File.join(@context.main_folder, FILE_LIST_FOLDER_NAME)
-        RestErrorAnalyzer.instance.log_file   = File.join(@context.main_folder, REST_EXCEPTIONS_LOG_FILENAME)
-        RestErrorsAspera.register_handlers
+        Rest::ErrorAnalyzer.instance.log_file = File.join(@context.main_folder, REST_EXCEPTIONS_LOG_FILENAME)
+        Rest::AsperaErrors.register_handlers
       end
 
       # @return [String] ~/.aspera

data/lib/aspera/cli/command_line.rb

@@ -0,0 +1,252 @@
+# frozen_string_literal: true
+
+require 'aspera/cli/error'
+require 'aspera/dot_container'
+require 'aspera/log'
+require 'aspera/assert'
+
+module Aspera
+  module Cli
+    # Positional (non-option) command line token.
+    class Argument
+      # @return [String] the raw argument value
+      attr_reader :value
+      # @return [Option, nil] option token claiming this token as its value (`--opt value` form)
+      attr_accessor :owner
+      # @return [Boolean] `true` once used, as positional argument or as option value
+      attr_accessor :consumed
+
+      def initialize(value)
+        @value = value
+        @owner = nil
+        @consumed = false
+      end
+
+      # @return [Boolean] `true` if available as positional argument
+      def positional? = !@consumed && @owner.nil?
+
+      # @return [String] raw argument value
+      def to_s = @value
+    end
+
+    # Option command line token (long or short form).
+    class Option
+      # @return [String] raw token as it appeared in argv (e.g. "--log-level=debug", "-Pval")
+      attr_reader :raw
+      # @return [String, nil] option name with underscores (e.g. "log_level"), nil for short options
+      attr_reader :name
+      # @return [String, nil] single-char short option letter (e.g. "P"), nil for long options
+      attr_reader :short_char
+      # @return [Array<String>, nil] sub-keys for dot-path notation (e.g. ["field"] for --custom.field)
+      attr_reader :dot_path
+      # @return [String, nil] value given in the same token (`--opt=val` or `-Oval`)
+      attr_reader :inline_value
+      # @return [Argument, nil] next token, claimed as value when there is no inline value (`--opt val` or `-O val`)
+      attr_accessor :value_token
+      # @return [Boolean] `true` once applied to a declared option
+      attr_accessor :consumed
+      # @return [Symbol, nil] option this token was resolved to, when `name` is an abbreviation
+      attr_accessor :abbreviation_of
+
+      def initialize(raw:, name: nil, short_char: nil, dot_path: nil, inline_value: nil)
+        @raw          = raw
+        @name         = name
+        @short_char   = short_char
+        @dot_path     = dot_path
+        @inline_value = inline_value
+        @value_token  = nil
+        @consumed     = false
+        @abbreviation_of = nil
+      end
+
+      # @return [Boolean] `true` if value is in the same token
+      def inline? = !@inline_value.nil?
+
+      # @return [String, nil] inline value, or value of next token
+      def value = @inline_value || @value_token&.value
+
+      # @return [String] raw token, followed by its separate value if any
+      def to_s = @value_token.nil? ? @raw : "#{@raw} #{@value_token.value}"
+
+      class << self
+        # @param token [String] command line token
+        # @return [Boolean] `true` if token is an option, i.e. not `-`, `--`, or a negative number
+        def option?(token)
+          token.match?(/\A-\D/) && !token.eql?(STOP)
+        end
+
+        # Build an Option from a raw token
+        # @param raw [String] e.g. "--log-level=debug", "--custom.field", "-P", "-Pval"
+        # @return [Option]
+        def parse(raw)
+          if raw.start_with?(PREFIX)
+            name_raw, value = raw.delete_prefix(PREFIX).split(VALUE_SEP, 2)
+            root, *dot_path = name_raw.to_s.split(DotContainer::SEPARATOR)
+            new(raw: raw, name: root.to_s.gsub(NAME_SEP_LINE, NAME_SEP_SYMBOL), dot_path: dot_path.empty? ? nil : dot_path, inline_value: value)
+          else
+            new(raw: raw, short_char: raw[1], inline_value: raw.length > 2 ? raw[2..] : nil)
+          end
+        end
+      end
+
+      # Option name separator on command line (e.g. `--option-name`, the `-` between words)
+      NAME_SEP_LINE   = '-'
+      # Option name separator in code/symbol (e.g. `:option_name`, the `_` between words)
+      NAME_SEP_SYMBOL = '_'
+      # Separator between option name and its inline value (e.g. `--opt=val`, the `=`)
+      VALUE_SEP = '='
+      # Long-option prefix (e.g. `--opt`)
+      PREFIX = '--'
+      # When alone, stops option processing: following tokens are positional arguments
+      STOP = '--'
+    end
+
+    # Command line split in tokens, in original order.
+    # Tokens are never removed, only marked as consumed, so that positions are kept.
+    #
+    # An option without inline value claims the next token as its value (`--opt val`, `-O val`),
+    # unless that token looks like an option.
+    # If the option turns out to be a flag, the claimed token is given back to positional arguments.
+    class CommandLine
+      # @param argv [Array<String>] command line arguments
+      def initialize(argv)
+        # @type [Array<Option, Argument>]
+        @tokens = []
+        # Option token being applied (used by `@:` extended value)
+        @current_option = nil
+        # When set, only positional arguments after this token are available
+        @arguments_after = nil
+        process_options = true
+        argv.each do |value|
+          if process_options && value.eql?(Option::STOP)
+            process_options = false
+          elsif process_options && Option.option?(value)
+            @tokens.push(Option.parse(value))
+          else
+            argument = Argument.new(value)
+            previous = @tokens.last
+            if process_options && previous.is_a?(Option) && !previous.inline? && previous.value_token.nil?
+              previous.value_token = argument
+              argument.owner = previous
+            end
+            @tokens.push(argument)
+          end
+        end
+        Log.log.trace1 { "arguments=#{pending_arguments},options=#{pending_options}" }
+      end
+
+      # @return [Array<Option>] option tokens whose name was resolved as an abbreviation
+      def abbreviated_option_tokens
+        @tokens.select { |t| t.is_a?(Option) && !t.abbreviation_of.nil? }
+      end
+
+      # @return [Array<Option>] option tokens not applied yet
+      def pending_option_tokens
+        @tokens.select { |t| t.is_a?(Option) && !t.consumed }
+      end
+
+      # Mark option token as applied, and get its value.
+      # @param tok         [Option]  option token
+      # @param takes_value [Boolean] `false` for flags: claimed token is given back to positional arguments
+      # @return [String, nil] value, or `nil` for flags
+      # @raise [BadArgument] if option takes a value and none was given
+      def consume(tok, takes_value:)
+        tok.consumed = true
+        return release(tok) unless takes_value
+        return tok.inline_value if tok.inline?
+        Aspera.assert(!tok.value_token.nil?, type: BadArgument) { "Option #{tok.raw} requires a value" }
+        tok.value_token.consumed = true
+        tok.value_token.value
+      end
+
+      # Execute block with `tok` as current option
+      # @param tok [Option] option token being applied
+      def with_current_option(tok)
+        @current_option = tok
+        yield
+      ensure
+        @current_option = nil
+      end
+
+      # Execute block with only positional arguments after current option available, if any
+      def with_arguments_after_current_option
+        @arguments_after = @current_option
+        yield
+      ensure
+        @arguments_after = nil
+      end
+
+      # @return [Array<String>] values of available positional arguments
+      def pending_arguments
+        positional_tokens.map(&:value)
+      end
+
+      # @return [Array<String>] options not applied yet, with their value if separate
+      def pending_options
+        pending_option_tokens.map(&:to_s)
+      end
+
+      # Consume positional arguments.
+      # @param multiple [false, true, String] consumption mode:
+      #   false  — consume exactly one token
+      #   true   — consume all remaining tokens
+      #   String — consume up to the marker token (marker is consumed too, not returned), or all if absent
+      # @return [Array<String>] consumed values
+      def shift_arguments(multiple)
+        arg_tokens = positional_tokens
+        selected =
+          case multiple
+          when false then arg_tokens.first(1)
+          when true then arg_tokens
+          when String
+            index = arg_tokens.index { |t| t.value.eql?(multiple) }
+            arg_tokens[index].consumed = true unless index.nil?
+            arg_tokens.take(index || arg_tokens.length)
+          else Aspera.error_unexpected_value(multiple) { 'multiple' }
+          end
+        selected.each { |t| t.consumed = true }
+        selected.map(&:value)
+      end
+
+      # Add an argument before the available positional arguments
+      # @param value [String] argument value
+      def unshift_argument(value)
+        index = @tokens.index { |t| t.is_a?(Argument) && t.positional? } || @tokens.length
+        @tokens.insert(index, Argument.new(value))
+      end
+
+      # Consume all long options with a value, whether applied or not.
+      # @yieldparam tok [Option] long option token with a value
+      def each_long_option_with_value
+        @tokens.each do |tok|
+          next unless tok.is_a?(Option) && tok.short_char.nil? && !tok.value.nil?
+          yield(tok)
+          tok.consumed = true
+          tok.value_token&.consumed = true
+        end
+      end
+
+      private
+
+      # Give back claimed token to positional arguments.
+      # @param tok [Option] flag option token
+      # @return [nil]
+      def release(tok)
+        value_token = tok.value_token
+        return if value_token.nil?
+        index = @tokens.index { |t| t.equal?(value_token) }
+        Aspera.assert(@tokens[index + 1..].none? { |t| t.is_a?(Argument) && t.consumed && t.owner.nil? }) do
+          "Flag #{tok.raw} declared after following positional arguments were used"
+        end
+        value_token.owner = nil
+        tok.value_token = nil
+      end
+
+      # @return [Array<Argument>] available positional arguments, in order
+      def positional_tokens
+        start = @arguments_after.nil? ? 0 : @tokens.index { |t| t.equal?(@arguments_after) } + 1
+        @tokens[start..].select { |t| t.is_a?(Argument) && t.positional? }
+      end
+    end
+  end
+end