aspera-cli 4.17.0 → 4.18.0

data/lib/aspera/cli/manager.rb

@@ -56,6 +56,9 @@ module Aspera
       OPTION_SEP_SYMBOL = '_'
       SOURCE_USER = 'cmdline' # cspell:disable-line
       TYPE_INTEGER = [Integer].freeze
+      OPTION_VALUE_SEPARATOR = '='
+      OPTION_PREFIX = '--'
+      OPTIONS_STOP = '--'
 
       private_constant :FALSE_VALUES, :TRUE_VALUES, :BOOLEAN_VALUES, :OPTION_SEP_LINE, :OPTION_SEP_SYMBOL, :SOURCE_USER, :TYPE_INTEGER
 
@@ -94,7 +97,7 @@ module Aspera
         end
 
         def option_name_to_line(name)
-          return "--#{name.to_s.gsub(OPTION_SEP_SYMBOL, OPTION_SEP_LINE)}"
+          return "#{OPTION_PREFIX}#{name.to_s.gsub(OPTION_SEP_SYMBOL, OPTION_SEP_LINE)}"
         end
 
         # @param what [Symbol] :option or :argument
@@ -115,22 +118,24 @@ module Aspera
       attr_writer :fail_on_missing_mandatory
 
       def initialize(program_name)
-        # command line values not starting with '-'
+        # command line values *not* starting with '-'
         @unprocessed_cmd_line_arguments = []
         # command line values starting with '-'
         @unprocessed_cmd_line_options = []
         # a copy of all initial options
         @initial_cli_options = []
-        # option description: key = option symbol, value=hash, :read_write, :accessor, :value, :accepted
+        # option description: key = option symbol, value=Hash, :read_write, :accessor, :value, :accepted
         @declared_options = {}
         # do we ask missing options and arguments to user ?
         @ask_missing_mandatory = false # STDIN.isatty
         # ask optional options if not provided and in interactive
         @ask_missing_optional = false
         @fail_on_missing_mandatory = true
-        # those must be set before parse, parse consumes those defined only
-        @unprocessed_defaults = []
-        @unprocessed_env = []
+        # Array of [key(sym), value]
+        # those must be set before parse
+        # parse consumes those defined only
+        @option_pairs_batch = {}
+        @option_pairs_env = {}
         # NOTE: was initially inherited but it is preferred to have specific methods
         @parser = OptionParser.new
         @parser.program_name = program_name
@@ -138,10 +143,10 @@ module Aspera
         env_prefix = program_name.upcase + OPTION_SEP_SYMBOL
         ENV.each do |k, v|
           if k.start_with?(env_prefix)
-            @unprocessed_env.push([k[env_prefix.length..-1].downcase.to_sym, v])
+            @option_pairs_env[k[env_prefix.length..-1].downcase.to_sym] = v
           end
         end
-        Log.log.debug{"env=#{@unprocessed_env}".red}
+        Log.log.debug{"env=#{@option_pairs_env}".red}
         @unprocessed_cmd_line_options = []
         @unprocessed_cmd_line_arguments = []
       end
@@ -156,16 +161,18 @@ module Aspera
         until argv.empty?
           value = argv.shift
           if process_options && value.start_with?('-')
-            if value.eql?('--')
+            Log.log.trace1{"opt: #{value}"}
+            if value.eql?(OPTIONS_STOP)
               process_options = false
             else
               @unprocessed_cmd_line_options.push(value)
             end
           else
+            Log.log.trace1{"arg: #{value}"}
             @unprocessed_cmd_line_arguments.push(value)
           end
         end
-        @initial_cli_options = @unprocessed_cmd_line_options.dup
+        @initial_cli_options = @unprocessed_cmd_line_options.dup.freeze
         Log.log.debug{"add_cmd_line_options:commands/arguments=#{@unprocessed_cmd_line_arguments},options=#{@unprocessed_cmd_line_options}".red}
       end
 
@@ -232,6 +239,7 @@ module Aspera
       # ask interactively if requested/required
       # @param mandatory [Boolean] if true, raise error if option not set
       def get_option(option_symbol, mandatory: false, default: nil)
+        Aspera.assert_type(option_symbol, Symbol)
         attributes = @declared_options[option_symbol]
         Aspera.assert(attributes){"option not declared: #{option_symbol}"}
         result = nil
@@ -268,6 +276,7 @@ module Aspera
 
       # set an option value by name, either store value or call handler
       def set_option(option_symbol, value, where='code override')
+        Aspera.assert_type(option_symbol, Symbol)
         raise Cli::BadArgument, "Unknown option: #{option_symbol}" unless @declared_options.key?(option_symbol)
         attributes = @declared_options[option_symbol]
         Log.log.warn("#{option_symbol}: Option is deprecated: #{attributes[:deprecation]}") if attributes[:deprecation]
@@ -292,10 +301,11 @@ module Aspera
       # @param default [Object] default value
       # @param values [nil, Array, :bool, :date, :none] list of allowed values, :bool for true/false, :date for dates, :none for on/off switch
       # @param short [String] short option name
-      # @param coerce [Class] one of the coerce types accepted par option parser
+      # @param coerce [Class] one of the coerce types accepted by option parser
       # @param types [Class, Array] accepted value type(s)
       # @param block [Proc] block to execute when option is found
       def declare(option_symbol, description, handler: nil, default: nil, values: nil, short: nil, coerce: nil, types: nil, deprecation: nil, &block)
+        Aspera.assert_type(option_symbol, Symbol)
         Aspera.assert(!@declared_options.key?(option_symbol)){"#{option_symbol} already declared"}
         Aspera.assert(description[-1] != '.'){"#{option_symbol} ends with dot"}
         Aspera.assert(description[0] == description[0].upcase){"#{option_symbol} description does not start with capital"}
@@ -307,7 +317,7 @@ module Aspera
         }
         if !types.nil?
           types = [types] unless types.is_a?(Array)
-          Aspera.assert(types.all?(Class)){"types must be Array of Class: #{types}"}
+          Aspera.assert(types.all?(Class)){"types must be (Array of) Class: #{types}"}
           opt[:types] = types
           description = "#{description} (#{types.map(&:name).join(', ')})"
         end
@@ -358,7 +368,7 @@ module Aspera
           end
         when :none
           Aspera.assert(!block.nil?){"missing block for #{option_symbol}"}
-          on_args.push(symbol_to_option(option_symbol, nil))
+          on_args.push(symbol_to_option(option_symbol))
           on_args.push("-#{short}") if short.is_a?(String)
           @parser.on(*on_args, &block)
         else Aspera.error_unexpected_value(values)
@@ -368,11 +378,13 @@ module Aspera
 
       # Adds each of the keys of specified hash as an option
       # @param preset_hash [Hash] hash of options to add
-      def add_option_preset(preset_hash, op: :push)
+      def add_option_preset(preset_hash, where, override: true)
         Aspera.assert_type(preset_hash, Hash)
-        Log.log.debug{"add_option_preset=#{preset_hash}"}
-        # incremental override
-        preset_hash.each{|k, v|@unprocessed_defaults.send(op, [k.to_sym, v])}
+        Log.log.debug{"add_option_preset: #{preset_hash}, #{where}, #{override}"}
+        preset_hash.each do |k, v|
+          option_symbol = k.to_sym
+          @option_pairs_batch[option_symbol] = v if override || !@option_pairs_batch.key?(option_symbol)
+        end
       end
 
       # check if there were unprocessed values to generate error
@@ -389,20 +401,20 @@ module Aspera
       end
 
       # get all original options on command line used to generate a config in config file
-      def get_options_table(remove_from_remaining: true)
+      def unprocessed_options_with_value
         result = {}
         @initial_cli_options.each do |option_value|
           case option_value
-          when /^--([^=]+)$/
+          when /^#{OPTION_PREFIX}([^=]+)$/o
             # ignore
-          when /^--([^=]+)=(.*)$/
+          when /^#{OPTION_PREFIX}([^=]+)=(.*)$/o
             name = Regexp.last_match(1)
             value = Regexp.last_match(2)
             name.gsub!(OPTION_SEP_LINE, OPTION_SEP_SYMBOL)
             value = ExtendedValue.instance.evaluate(value)
             Log.log.debug{"option #{name}=#{value}"}
             result[name] = value
-            @unprocessed_cmd_line_options.delete(option_value) if remove_from_remaining
+            @unprocessed_cmd_line_options.delete(option_value)
           else
             raise Cli::BadArgument, "wrong option format: #{option_value}"
           end
@@ -425,8 +437,8 @@ module Aspera
       def parse_options!
         Log.log.debug('parse_options!'.red)
         # first conf file, then env var
-        apply_options_preset(@unprocessed_defaults, 'file')
-        apply_options_preset(@unprocessed_env, 'env')
+        consume_option_pairs(@option_pairs_batch, 'set')
+        consume_option_pairs(@option_pairs_env, 'env')
         # command line override
         unknown_options = []
         begin
@@ -497,9 +509,9 @@ module Aspera
       private
 
       # generate command line option from option symbol
-      def symbol_to_option(symbol, opt_val)
-        result = '--' + symbol.to_s.gsub(OPTION_SEP_SYMBOL, OPTION_SEP_LINE)
-        result = result + '=' + opt_val unless opt_val.nil?
+      def symbol_to_option(symbol, opt_val = nil)
+        result = [OPTION_PREFIX, symbol.to_s.gsub(OPTION_SEP_SYMBOL, OPTION_SEP_LINE)].join
+        result = [result, OPTION_VALUE_SEPARATOR, opt_val].join unless opt_val.nil?
         return result
       end
 
@@ -507,23 +519,28 @@ module Aspera
         $stdout.isatty ? value.to_s.red.bold : "[#{value}]"
       end
 
-      def apply_options_preset(preset, where)
-        unprocessed = []
-        preset.each do |pair|
-          k, v = *pair
+      # try to evaluate options set ib batch
+      # @param unprocessed_options [Array] list of options to apply (key_sym,value)
+      # @param where [String] where the options come from
+      def consume_option_pairs(unprocessed_options, where)
+        Log.log.debug{"consume_option_pairs: #{where}"}
+        options_to_set = {}
+        unprocessed_options.each do |k, v|
           if @declared_options.key?(k)
             # constrained parameters as string are revert to symbol
             if @declared_options[k].key?(:values) && v.is_a?(String)
-              v = self.class.get_from_list(v, k.to_s + " in #{where}", @declared_options[k][:values])
+              v = self.class.get_from_list(v, "#{k} in #{where}", @declared_options[k][:values])
             end
-            set_option(k, v, where)
+            options_to_set[k] = v
           else
-            unprocessed.push(pair)
+            Log.log.debug{"unprocessed: #{k}: #{v}"}
           end
         end
-        # keep only unprocessed values for next parse
-        preset.clear
-        preset.push(*unprocessed)
+        options_to_set.each do |k, v|
+          set_option(k, v, where)
+          # keep only unprocessed values for next parse
+          unprocessed_options.delete(k)
+        end
       end
     end
   end

data/lib/aspera/cli/plugin.rb

@@ -19,6 +19,7 @@ module Aspera
       MAX_PAGES = 'pmax'
       # special identifier format: look for this name to find where supported
       REGEX_LOOKUP_ID_BY_FIELD = /^%([^:]+):(.*)$/.freeze
+      # instance variables, also constructor parameters
       INIT_PARAMS = %i[options transfer config formatter persistency only_manual].freeze
 
       class << self
@@ -62,15 +63,16 @@ module Aspera
       # @param description [String] description of the identifier
       # @param as_option [Symbol] option name to use if identifier is an option
       # @param block [Proc] block to search for identifier based on attribute value
-      # @return [String] identifier
+      # @return [String, Array] identifier or list of ids
       def instance_identifier(description: 'identifier', as_option: nil, &block)
         if as_option.nil?
+          # use of option `id` is deprecated
           res_id = options.get_option(:id)
           res_id = options.get_next_argument(description) if res_id.nil?
         else
           res_id = options.get_option(as_option)
         end
-        # cab be an Array
+        # can be an Array
         if res_id.is_a?(String) && (m = res_id.match(REGEX_LOOKUP_ID_BY_FIELD))
           if block
             res_id = yield(m[1], ExtendedValue.instance.evaluate(m[2]))
@@ -108,7 +110,9 @@ module Aspera
             # execute custom code
             res = yield(param)
             # if block returns a hash, let's use this (create)
-            result = res if param.is_a?(Hash)
+            result = res if res.is_a?(Hash)
+            # TODO: remove when faspio gw api fixes this
+            result = res.first if res.is_a?(Array) && res.first.is_a?(Hash)
             # create -> created
             result['status'] = "#{command}#{'e' unless command.to_s.end_with?('e')}d".gsub(/yed$/, 'ied')
           rescue StandardError => e
@@ -133,9 +137,16 @@ module Aspera
       # @param item_list_key [String] result is in a sub key of the json
       # @param id_as_arg [String] if set, the id is provided as url argument ?<id_as_arg>=<id>
       # @param is_singleton [Boolean] if true, res_class_path is the full path to the resource
+      # @param delete_style [String] if set, the delete operation by array in payload
       # @param block [Proc] block to search for identifier based on attribute value
       # @return result suitable for CLI result
-      def entity_command(command, rest_api, res_class_path, display_fields: nil, item_list_key: false, id_as_arg: false, is_singleton: false, &block)
+      def entity_command(command, rest_api, res_class_path,
+        display_fields: nil,
+        item_list_key: false,
+        id_as_arg: false,
+        is_singleton: false,
+        delete_style: nil,
+        &block)
         if is_singleton
           one_res_path = res_class_path
         elsif INSTANCE_OPS.include?(command)
@@ -152,14 +163,20 @@ module Aspera
           end
         when :delete
           raise 'cannot delete singleton' if is_singleton
+          if !delete_style.nil?
+            one_res_id = [one_res_id] unless one_res_id.is_a?(Array)
+            Aspera.assert_type(one_res_id, Array, exception_class: Cli::BadArgument)
+            rest_api.call(operation: 'DELETE', subpath: res_class_path, headers: {'Accept' => 'application/json'}, body: {delete_style => one_res_id}, body_type: :json)
+            return Main.result_status('deleted')
+          end
           return do_bulk_operation(command: command, descr: 'identifier', values: one_res_id) do |one_id|
-            rest_api.delete("#{res_class_path}/#{one_id}", old_query_read_delete)
+            rest_api.delete("#{res_class_path}/#{one_id}", query_read_delete)
             {'id' => one_id}
           end
         when :show
           return {type: :single_object, data: rest_api.read(one_res_path)[:data], fields: display_fields}
         when :list
-          resp = rest_api.read(res_class_path, old_query_read_delete)
+          resp = rest_api.read(res_class_path, query_read_delete)
           return Main.result_empty if resp[:http].code == '204'
           data = resp[:data]
           # TODO: not generic : which application is this for ?
@@ -215,14 +232,6 @@ module Aspera
         return query
       end
 
-      # TODO: when deprecation of `value` is completed: remove this method, replace with query_read_delete
-      # deprecation: 4.14
-      def old_query_read_delete
-        query = options.get_option(:value) # legacy, deprecated, remove, one day...
-        query = query_read_delete if query.nil?
-        return query
-      end
-
       # TODO: when deprecation of `value` is completed: remove this method, replace with options.get_option(:query)
       # deprecation: 4.14
       def query_option(mandatory: false, default: nil)
@@ -262,6 +271,6 @@ module Aspera
         end
         return value
       end
-    end # Plugin
-  end # Cli
-end # Aspera
+    end
+  end
+end

data/lib/aspera/cli/plugin_factory.rb

@@ -6,34 +6,25 @@ module Aspera
     # option is retrieved from another object using accessor
     class PluginFactory
       include Singleton
-      attr_reader :lookup_folders, :plugins
 
       RUBY_FILE_EXT = '.rb'
       PLUGINS_MODULE = 'Plugins'
-      private_constant :RUBY_FILE_EXT
-      class << self
-        # instantiate a plugin
-        # plugins must be Capitalized
-        def plugin_class(plugin_name_sym)
-          # Module.nesting[2] is Cli::Plugins
-          return Object.const_get("#{Module.nesting[2]}::#{PLUGINS_MODULE}::#{plugin_name_sym.to_s.capitalize}")
-        end
-      end
+      private_constant :RUBY_FILE_EXT, :PLUGINS_MODULE
+
+      attr_reader :lookup_folders
 
       def initialize
         @lookup_folders = []
+        # information on plugins
         @plugins = {}
       end
 
-      def add_plugin_info(path)
-        raise "ERROR: plugin path must end with #{RUBY_FILE_EXT}" if !path.end_with?(RUBY_FILE_EXT)
-        plugin_symbol = File.basename(path, RUBY_FILE_EXT).to_sym
-        req = path.sub(/#{RUBY_FILE_EXT}$/o, '')
-        if @plugins.key?(plugin_symbol)
-          Log.log.warn{"skipping plugin already registered: #{plugin_symbol}"}
-          return
-        end
-        @plugins[plugin_symbol] = {source: path, require_stanza: req}
+      def plugin_list
+        @plugins.keys
+      end
+
+      def plugin_source(plugin_name_sym)
+        @plugins[plugin_name_sym][:source]
       end
 
       def add_lookup_folder(folder)
@@ -52,9 +43,29 @@ module Aspera
         end
       end
 
+      def plugin_class(plugin_name_sym)
+        raise "ERROR: plugin not found: #{plugin_name_sym}" unless @plugins.key?(plugin_name_sym)
+        require @plugins[plugin_name_sym][:require_stanza]
+        # Module.nesting[1] is Aspera::Cli
+        return Object.const_get("#{Module.nesting[1]}::#{PLUGINS_MODULE}::#{plugin_name_sym.to_s.capitalize}")
+      end
+
       def create(plugin_name_sym, **args)
         # TODO: check that ancestor is Plugin?
-        self.class.plugin_class(plugin_name_sym).new(**args)
+        plugin_class(plugin_name_sym).new(**args)
+      end
+
+      private
+
+      def add_plugin_info(path)
+        raise "ERROR: plugin path must end with #{RUBY_FILE_EXT}" if !path.end_with?(RUBY_FILE_EXT)
+        plugin_symbol = File.basename(path, RUBY_FILE_EXT).to_sym
+        req = path.sub(/#{RUBY_FILE_EXT}$/o, '')
+        if @plugins.key?(plugin_symbol)
+          Log.log.warn{"skipping plugin already registered: #{plugin_symbol}"}
+          return
+        end
+        @plugins[plugin_symbol] = {source: path, require_stanza: req}
       end
     end
   end

data/lib/aspera/cli/plugins/alee.rb

@@ -1,20 +1,32 @@
 # frozen_string_literal: true
 
 require 'aspera/api/aoc'
+require 'aspera/nagios'
 
 module Aspera
   module Cli
     module Plugins
       class Alee < Cli::BasicAuthPlugin
-        ACTIONS = %i[entitlement].freeze
+        ACTIONS = %i[health entitlement].freeze
 
         def execute_action
           command = options.get_next_command(ACTIONS)
           case command
+          when :health
+            nagios = Nagios.new
+            begin
+              api = Api::Alee.new(nil, nil, version: 'ping')
+              result = api.call(operation: 'GET', subpath: '')
+              raise "unexpected response: #{result[:http].body}" unless result[:http].body.eql?('pong')
+              nagios.add_ok('api', 'answered ok')
+            rescue StandardError => e
+              nagios.add_critical('api', e.to_s)
+            end
+            return nagios.result
           when :entitlement
             entitlement_id = options.get_option(:username, mandatory: true)
             customer_id = options.get_option(:password, mandatory: true)
-            api_metering = Api::AoC.metering_api(entitlement_id, customer_id)
+            api_metering = Api::Alee.new(entitlement_id, customer_id)
             return {type: :single_object, data: api_metering.read('entitlement')[:data]}
           end
         end