aspera-cli 4.7.0 → 4.9.0

data/lib/aspera/cli/manager.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'aspera/colors'
 require 'aspera/log'
 require 'aspera/cli/extended_value'
@@ -15,7 +16,7 @@ module Aspera
 
     class CliNoSuchId < CliError
       def initialize(res_type,res_id)
-        msg="No such #{res_type} identifier: #{res_id}"
+        msg = "No such #{res_type} identifier: #{res_id}"
         super(msg)
       end
     end
@@ -25,8 +26,8 @@ module Aspera
       #attr_accessor :object
       #attr_accessor :attr_symb
       def initialize(object,attr_symb)
-        @object=object
-        @attr_symb=attr_symb
+        @object = object
+        @attr_symb = attr_symb
       end
 
       def value
@@ -43,19 +44,19 @@ module Aspera
     # resolves on extended value syntax
     class Manager
       # boolean options are set to true/false from the following values
-      TRUE_VALUES=[:yes,true].freeze
-      BOOLEAN_VALUES=[TRUE_VALUES,:no,false].flatten.freeze
-      BOOLEAN_SIMPLE=[:yes,:no].freeze
+      TRUE_VALUES = [:yes,true].freeze
+      BOOLEAN_VALUES = [TRUE_VALUES,:no,false].flatten.freeze
+      BOOLEAN_SIMPLE = %i[yes no].freeze
       # option name separator on command line
-      OPTION_SEP_LINE='-'
+      OPTION_SEP_LINE = '-'
       # option name separator in code (symbol)
-      OPTION_SEP_NAME='_'
+      OPTION_SEP_NAME = '_'
 
-      private_constant :TRUE_VALUES,:BOOLEAN_VALUES,:BOOLEAN_SIMPLE,:OPTION_SEP_LINE,:OPTION_SEP_NAME
+      private_constant :TRUE_VALUES,:BOOLEAN_VALUES,:OPTION_SEP_LINE,:OPTION_SEP_NAME
 
       class << self
         def enum_to_bool(enum)
-          raise "Value not valid for boolean: #{enum}/#{enum.class}" unless BOOLEAN_VALUES.include?(enum)
+          raise "Value not valid for boolean: [#{enum}]/#{enum.class}" unless BOOLEAN_VALUES.include?(enum)
           return TRUE_VALUES.include?(enum)
         end
 
@@ -66,9 +67,9 @@ module Aspera
         # find shortened string value in allowed symbol list
         def get_from_list(shortval,descr,allowed_values)
           # we accept shortcuts
-          matching_exact=allowed_values.select{|i| i.to_s.eql?(shortval)}
+          matching_exact = allowed_values.select{|i| i.to_s.eql?(shortval)}
           return matching_exact.first if matching_exact.length == 1
-          matching=allowed_values.select{|i| i.to_s.start_with?(shortval)}
+          matching = allowed_values.select{|i| i.to_s.start_with?(shortval)}
           raise CliBadArgument,bad_arg_message_multi("unknown value for #{descr}: #{shortval}",allowed_values) if matching.empty?
           raise CliBadArgument,bad_arg_message_multi("ambigous shortcut for #{descr}: #{shortval}",matching) unless matching.length.eql?(1)
           return enum_to_bool(matching.first) if allowed_values.eql?(BOOLEAN_VALUES)
@@ -84,36 +85,36 @@ module Aspera
       attr_accessor :ask_missing_mandatory, :ask_missing_optional
       attr_writer :fail_on_missing_mandatory
 
-      def initialize(program_name,argv=nil)
+      def initialize(program_name,argv: nil)
         # command line values not starting with '-'
-        @unprocessed_cmd_line_arguments=[]
+        @unprocessed_cmd_line_arguments = []
         # command line values starting with '-'
-        @unprocessed_cmd_line_options=[]
+        @unprocessed_cmd_line_options = []
         # a copy of all initial options
-        @initial_cli_options=[]
+        @initial_cli_options = []
         # option description: key = option symbol, value=hash, :type, :accessor, :value, :accepted
-        @declared_options={}
+        @declared_options = {}
         # do we ask missing options and arguments to user ?
-        @ask_missing_mandatory=false # STDIN.isatty
+        @ask_missing_mandatory = false # STDIN.isatty
         # ask optional options if not provided and in interactive
-        @ask_missing_optional=false
-        @fail_on_missing_mandatory=true
+        @ask_missing_optional = false
+        @fail_on_missing_mandatory = true
         # those must be set before parse, parse consumes those defined only
-        @unprocessed_defaults=[]
-        @unprocessed_env=[]
+        @unprocessed_defaults = []
+        @unprocessed_env = []
         # Note: was initially inherited but it is prefered to have specific methods
-        @parser=OptionParser.new
-        @parser.program_name=program_name
+        @parser = OptionParser.new
+        @parser.program_name = program_name
         # options can also be provided by env vars : --param-name -> ASLMCLI_PARAM_NAME
-        env_prefix=program_name.upcase+OPTION_SEP_NAME
+        env_prefix = program_name.upcase + OPTION_SEP_NAME
         ENV.each do |k,v|
           if k.start_with?(env_prefix)
             @unprocessed_env.push([k[env_prefix.length..-1].downcase.to_sym,v])
           end
         end
         Log.log.debug("env=#{@unprocessed_env}".red)
-        @unprocessed_cmd_line_options=[]
-        @unprocessed_cmd_line_arguments=[]
+        @unprocessed_cmd_line_options = []
+        @unprocessed_cmd_line_arguments = []
         # argv is nil when help is generated for every plugin
         unless argv.nil?
           @parser.separator('')
@@ -123,12 +124,12 @@ module Aspera
           add_opt_boolean(:interactive,'use interactive input of missing params')
           add_opt_boolean(:ask_options,'ask even optional options')
           parse_options!
-          process_options=true
+          process_options = true
           while !argv.empty?
-            value=argv.shift
+            value = argv.shift
             if process_options && value.start_with?('-')
               if value.eql?('--')
-                process_options=false
+                process_options = false
               else
                 @unprocessed_cmd_line_options.push(value)
               end
@@ -137,39 +138,45 @@ module Aspera
             end
           end
         end
-        @initial_cli_options=@unprocessed_cmd_line_options.dup
+        @initial_cli_options = @unprocessed_cmd_line_options.dup
         Log.log.debug("add_cmd_line_options:commands/args=#{@unprocessed_cmd_line_arguments},options=#{@unprocessed_cmd_line_options}".red)
       end
 
-      def get_next_command(command_list); return get_next_argument('command',command_list); end
+      def get_next_command(command_list); return get_next_argument('command',expected: command_list); end
 
       # @param expected is
       #    - Array of allowed value (single value)
       #    - :multiple for remaining values
       #    - :single for a single unconstrained value
-      # @param is_type : :mandatory or :optional
+      # @param mandatory true/false
+      # @param type expected class for result
       # @return value, list or nil
-      def get_next_argument(descr,expected=:single,is_type=:mandatory)
-        result=nil
+      def get_next_argument(descr,expected: :single,mandatory: true, type: nil)
+        unless type.nil?
+          raise 'internal: type must be a Class' unless type.is_a?(Class)
+          descr="#{descr} (#{type})"
+        end
+        result = nil
         if !@unprocessed_cmd_line_arguments.empty?
           # there are values
           case expected
           when :single
-            result=ExtendedValue.instance.evaluate(@unprocessed_cmd_line_arguments.shift)
+            result = ExtendedValue.instance.evaluate(@unprocessed_cmd_line_arguments.shift)
           when :multiple
             result = @unprocessed_cmd_line_arguments.shift(@unprocessed_cmd_line_arguments.length).map{|v|ExtendedValue.instance.evaluate(v)}
             # if expecting list and only one arg of type array : it is the list
             if result.length.eql?(1) && result.first.is_a?(Array)
-              result=result.first
+              result = result.first
             end
           else
-            result=self.class.get_from_list(@unprocessed_cmd_line_arguments.shift,descr,expected)
+            result = self.class.get_from_list(@unprocessed_cmd_line_arguments.shift,descr,expected)
           end
-        elsif is_type.eql?(:mandatory)
+        elsif mandatory
           # no value provided
-          result=get_interactive(:argument,descr,expected)
+          result = get_interactive(:argument,descr,expected: expected)
         end
         Log.log.debug("#{descr}=#{result}")
+        raise "argument shall be #{type.name}" unless type.nil? || result.is_a?(type)
         return result
       end
 
@@ -177,19 +184,20 @@ module Aspera
       def declare_option(option_symbol,type)
         Log.log.debug("declare_option: #{option_symbol}: #{type}: skip=#{@declared_options.has_key?(option_symbol)}".green)
         if @declared_options.has_key?(option_symbol)
-          raise "INTERNAL ERROR: option #{option_symbol} already declared. only accessor can be redeclared and ignored" unless @declared_options[option_symbol][:type].eql?(:accessor)
+          raise "INTERNAL ERROR: option #{option_symbol} already declared. only accessor can be redeclared and ignored" \
+          unless @declared_options[option_symbol][:type].eql?(:accessor)
           return
         end
-        @declared_options[option_symbol]={type: type}
+        @declared_options[option_symbol] = {type: type}
         # by default passwords and secrets are sensitive, else specify when declaring the option
-        @declared_options[option_symbol][:sensitive]=true if !%w[password secret key].select{|i| option_symbol.to_s.end_with?(i)}.empty?
+        @declared_options[option_symbol][:sensitive] = true if !%w[password secret key].select{|i| option_symbol.to_s.end_with?(i)}.empty?
       end
 
       # define option with handler
       def set_obj_attr(option_symbol,object,attr_symb,default_value=nil)
         Log.log.debug("set attr obj #{option_symbol} (#{object},#{attr_symb})")
         declare_option(option_symbol,:accessor)
-        @declared_options[option_symbol][:accessor]=AttrAccessor.new(object,attr_symb)
+        @declared_options[option_symbol][:accessor] = AttrAccessor.new(object,attr_symb)
         set_option(option_symbol,default_value,'default obj attr') if !default_value.nil?
       end
 
@@ -200,14 +208,14 @@ module Aspera
           raise 'ERROR: cannot set undeclared option'
           #declare_option(option_symbol)
         end
-        value=ExtendedValue.instance.evaluate(value)
-        value=Manager.enum_to_bool(value) if @declared_options[option_symbol][:values].eql?(BOOLEAN_VALUES)
-        Log.log.debug("set #{option_symbol}=#{value} (#{@declared_options[option_symbol][:type]}) : #{where}")
+        value = ExtendedValue.instance.evaluate(value)
+        value = Manager.enum_to_bool(value) if @declared_options[option_symbol][:values].eql?(BOOLEAN_VALUES)
+        Log.log.debug("(#{@declared_options[option_symbol][:type]}/#{where}) set #{option_symbol}=#{value}")
         case @declared_options[option_symbol][:type]
         when :accessor
-          @declared_options[option_symbol][:accessor].value=value
+          @declared_options[option_symbol][:accessor].value = value
         when :value
-          @declared_options[option_symbol][:value]=value
+          @declared_options[option_symbol][:value] = value
         else # nil or other
           raise 'error'
         end
@@ -216,33 +224,33 @@ module Aspera
       # get an option value by name
       # either return value or call handler, can return nil
       # ask interactively if requested/required
-      def get_option(option_symbol,is_type=:optional)
-        result=nil
+      def get_option(option_symbol,is_type: :optional)
+        result = nil
         if @declared_options.has_key?(option_symbol)
           case @declared_options[option_symbol][:type]
           when :accessor
-            result=@declared_options[option_symbol][:accessor].value
+            result = @declared_options[option_symbol][:accessor].value
           when :value
-            result=@declared_options[option_symbol][:value]
+            result = @declared_options[option_symbol][:value]
           else
             raise 'unknown type'
           end
-          Log.log.debug("get #{option_symbol} (#{@declared_options[option_symbol][:type]}) : #{result}")
+          Log.log.debug("(#{@declared_options[option_symbol][:type]}) get #{option_symbol}=#{result}")
         end
         # do not fail for manual generation if option mandatory but not set
-        result='' if result.nil? && !@fail_on_missing_mandatory
+        result = '' if result.nil? && is_type.eql?(:mandatory) && !@fail_on_missing_mandatory
         #Log.log.debug("interactive=#{@ask_missing_mandatory}")
         if result.nil?
           if !@ask_missing_mandatory
             raise CliBadArgument,"Missing mandatory option: #{option_symbol}" if is_type.eql?(:mandatory)
           elsif @ask_missing_optional || is_type.eql?(:mandatory)
             # ask_missing_mandatory
-            expected=:single
+            expected = :single
             #print "please enter: #{option_symbol.to_s}"
             if @declared_options.has_key?(option_symbol) && @declared_options[option_symbol].has_key?(:values)
-              expected=@declared_options[option_symbol][:values]
+              expected = @declared_options[option_symbol][:values]
             end
-            result=get_interactive(:option,option_symbol.to_s,expected)
+            result = get_interactive(:option,option_symbol.to_s,expected: expected)
             set_option(option_symbol,result,'interactive')
           end
         end
@@ -250,7 +258,7 @@ module Aspera
       end
 
       # param must be hash
-      def add_option_preset(preset_hash,op=:push)
+      def add_option_preset(preset_hash,op: :push)
         Log.log.debug("add_option_preset=#{preset_hash}")
         raise "internal error: setting default with no hash: #{preset_hash.class}" if !preset_hash.is_a?(Hash)
         # incremental override
@@ -263,11 +271,11 @@ module Aspera
         Log.log.debug("add_opt_list #{option_symbol}")
         on_args.unshift(symbol_to_option(option_symbol,'ENUM'))
         # this option value must be a symbol
-        @declared_options[option_symbol][:values]=values
-        value=get_option(option_symbol)
-        help_values=values.map{|i|i.eql?(value)?highlight_current(i):i}.join(', ')
+        @declared_options[option_symbol][:values] = values
+        value = get_option(option_symbol)
+        help_values = values.map{|i|i.eql?(value) ? highlight_current(i) : i}.join(', ')
         if values.eql?(BOOLEAN_VALUES)
-          help_values=BOOLEAN_SIMPLE.map{|i|(i.eql?(:yes) && value) || (i.eql?(:no) && !value) ? highlight_current(i) : i}.join(', ')
+          help_values = BOOLEAN_SIMPLE.map{|i|(i.eql?(:yes) && value) || (i.eql?(:no) && !value) ? highlight_current(i) : i}.join(', ')
         end
         on_args.push(values)
         on_args.push("#{help}: #{help_values}")
@@ -277,6 +285,9 @@ module Aspera
 
       def add_opt_boolean(option_symbol,help,*on_args)
         add_opt_list(option_symbol,BOOLEAN_VALUES,help,*on_args)
+        # if default was defined for obj, it may still be enum (yes/no) instead of boolean
+        default_value=get_option(option_symbol)
+        set_option(option_symbol,default_value,'opt boolean') unless default_value.nil?
       end
 
       # define an option with open values
@@ -297,7 +308,7 @@ module Aspera
         @parser.on(*on_args) do |v|
           case v
           when 'now' then set_option(option_symbol,Manager.time_to_string(Time.now),'cmdline')
-          when /^-([0-9]+)h/ then set_option(option_symbol,Manager.time_to_string(Time.now-(3600*Regexp.last_match(1).to_i)),'cmdline')
+          when /^-([0-9]+)h/ then set_option(option_symbol,Manager.time_to_string(Time.now - (3600 * Regexp.last_match(1).to_i)),'cmdline')
           else set_option(option_symbol,v,'cmdline')
           end
         end
@@ -318,7 +329,7 @@ module Aspera
 
       # unprocessed options or arguments ?
       def final_errors
-        result=[]
+        result = []
         result.push("unprocessed options: #{@unprocessed_cmd_line_options}") unless @unprocessed_cmd_line_options.empty?
         result.push("unprocessed values: #{@unprocessed_cmd_line_arguments}") unless @unprocessed_cmd_line_arguments.empty?
         return result
@@ -326,18 +337,18 @@ module Aspera
 
       # get all original options  on command line used to generate a config in config file
       def get_options_table(remove_from_remaining: true)
-        result={}
+        result = {}
         @initial_cli_options.each do |optionval|
           case optionval
           when /^--([^=]+)$/
             # ignore
           when /^--([^=]+)=(.*)$/
-            name=Regexp.last_match(1)
-            value=Regexp.last_match(2)
+            name = Regexp.last_match(1)
+            value = Regexp.last_match(2)
             name.gsub!(OPTION_SEP_LINE,OPTION_SEP_NAME)
-            value=ExtendedValue.instance.evaluate(value)
+            value = ExtendedValue.instance.evaluate(value)
             Log.log.debug("option #{name}=#{value}")
-            result[name]=value
+            result[name] = value
             @unprocessed_cmd_line_options.delete(optionval) if remove_from_remaining
           else
             raise CliBadArgument,"wrong option format: #{optionval}"
@@ -348,10 +359,10 @@ module Aspera
 
       # return options as taken from config file and command line just before command execution
       def declared_options(only_defined: false)
-        result={}
+        result = {}
         @declared_options.keys.each do |option_symb|
-          v=get_option(option_symb)
-          result[option_symb.to_s]=v unless only_defined && v.nil?
+          v = get_option(option_symb)
+          result[option_symb.to_s] = v unless only_defined && v.nil?
         end
         return result
       end
@@ -363,7 +374,7 @@ module Aspera
         apply_options_preset(@unprocessed_defaults,'file')
         apply_options_preset(@unprocessed_env,'env')
         # command line override
-        unknown_options=[]
+        unknown_options = []
         begin
           # remove known options one by one, exception if unknown
           Log.log.debug('before parse'.red)
@@ -377,47 +388,47 @@ module Aspera
         end
         Log.log.debug("remains: #{unknown_options}")
         # set unprocessed options for next time
-        @unprocessed_cmd_line_options=unknown_options
+        @unprocessed_cmd_line_options = unknown_options
       end
 
       private
 
       def prompt_user_input(prompt,sensitive)
         return $stdin.getpass("#{prompt}> ") if sensitive
-        print "#{prompt}> "
+        print("#{prompt}> ")
         return $stdin.gets.chomp
       end
 
-      def get_interactive(type,descr,expected=:single)
+      def get_interactive(type,descr,expected: :single)
         if !@ask_missing_mandatory
           raise CliBadArgument,self.class.bad_arg_message_multi("missing: #{descr}",expected) if expected.is_a?(Array)
           raise CliBadArgument,"missing argument (#{expected}): #{descr}"
         end
-        result=nil
+        result = nil
         sensitive = type.eql?(:option) && @declared_options[descr.to_sym][:sensitive]
-        default_prompt="#{type}: #{descr}"
+        default_prompt = "#{type}: #{descr}"
         # ask interactively
         case expected
         when :multiple
-          result=[]
+          result = []
           puts(' (one per line, end with empty line)')
           loop do
-            entry=prompt_user_input(default_prompt,sensitive)
+            entry = prompt_user_input(default_prompt,sensitive)
             break if entry.empty?
             result.push(ExtendedValue.instance.evaluate(entry))
           end
         when :single
-          result=ExtendedValue.instance.evaluate(prompt_user_input(default_prompt,sensitive))
+          result = ExtendedValue.instance.evaluate(prompt_user_input(default_prompt,sensitive))
         else # one fixed
-          result=self.class.get_from_list(prompt_user_input("#{expected.join(' ')}\n#{default_prompt}",sensitive),descr,expected)
+          result = self.class.get_from_list(prompt_user_input("#{expected.join(' ')}\n#{default_prompt}",sensitive),descr,expected)
         end
         return result
       end
 
       # generate command line option from option symbol
       def symbol_to_option(symbol,opt_val)
-        result='--'+symbol.to_s.gsub(OPTION_SEP_NAME,OPTION_SEP_LINE)
-        result=result+'='+opt_val unless opt_val.nil?
+        result = '--' + symbol.to_s.gsub(OPTION_SEP_NAME,OPTION_SEP_LINE)
+        result = result + '=' + opt_val unless opt_val.nil?
         return result
       end
 
@@ -426,13 +437,13 @@ module Aspera
       end
 
       def apply_options_preset(preset,where)
-        unprocessed=[]
+        unprocessed = []
         preset.each do |pair|
-          k,v=*pair
+          k,v = *pair
           if @declared_options.has_key?(k)
             # constrained parameters as string are revert to symbol
             if @declared_options[k].has_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.to_s + " in #{where}",@declared_options[k][:values])
             end
             set_option(k,v,where)
           else

data/lib/aspera/cli/plugin.rb

@@ -1,92 +1,151 @@
 # frozen_string_literal: true
+
 module Aspera
   module Cli
     # base class for plugins modules
     class Plugin
-      # operation without id
-      GLOBAL_OPS=[:create,:list].freeze
-      # operation on specific instance
-      INSTANCE_OPS=[:modify,:delete,:show].freeze
-      ALL_OPS=[GLOBAL_OPS,INSTANCE_OPS].flatten.freeze
+      # operations without id
+      GLOBAL_OPS = %i[create list].freeze
+      # operations with id
+      INSTANCE_OPS = %i[modify delete show].freeze
+      ALL_OPS = [GLOBAL_OPS,INSTANCE_OPS].flatten.freeze
       # max number of items for list command
-      MAX_ITEMS='max'
+      MAX_ITEMS = 'max'
       # max number of pages for list command
-      MAX_PAGES='pmax'
+      MAX_PAGES = 'pmax'
+
+      #AGENTS=%i[options transfer config formater persistency].freeze
 
       # global for inherited classes
-      @@options_created=false # rubocop:disable Style/ClassVars
+      @@options_created = false # rubocop:disable Style/ClassVars
 
       def initialize(env)
-        @agents=env
-        raise StandardError,"execute_action shall be redefined by subclass #{self.class}" unless respond_to?(:execute_action)
+        raise 'must be Hash' unless env.is_a?(Hash)
+        #env.each_key {|k| raise "wrong agent key #{k}" unless AGENTS.include?(k)}
+        @agents = env
+        # check presence in descendant of mandatory method and constant
+        raise StandardError,"missing method 'execute_action' in #{self.class}" unless respond_to?(:execute_action)
         raise StandardError,'ACTIONS shall be redefined by subclass' unless self.class.constants.include?(:ACTIONS)
-        unless env[:skip_option_header]
-          options.parser.separator ''
-          options.parser.separator "COMMAND: #{self.class.name.split('::').last.downcase}"
-          options.parser.separator "SUBCOMMANDS: #{self.class.const_get(:ACTIONS).map(&:to_s).join(' ')}"
-          options.parser.separator 'OPTIONS:'
-        end
+        options.parser.separator('')
+        options.parser.separator("COMMAND: #{self.class.name.split('::').last.downcase}")
+        options.parser.separator("SUBCOMMANDS: #{self.class.const_get(:ACTIONS).map(&:to_s).join(' ')}")
+        options.parser.separator('OPTIONS:')
         return if @@options_created
         options.add_opt_simple(:value,'extended value for create, update, list filter')
         options.add_opt_simple(:property,'name of property to set')
         options.add_opt_simple(:id,"resource identifier (#{INSTANCE_OPS.join(',')})")
+        options.add_opt_boolean(:bulk,'Bulk operation (only some)')
+        options.set_option(:bulk,:no)
         options.parse_options!
-        @@options_created=true # rubocop:disable Style/ClassVars
+        @@options_created = true # rubocop:disable Style/ClassVars
       end
 
       # must be called AFTER the instance action
       def instance_identifier
-        res_id=options.get_option(:id)
-        res_id=options.get_next_argument('identifier') if res_id.nil?
+        res_id = options.get_option(:id)
+        res_id = options.get_next_argument('identifier') if res_id.nil?
         return res_id
       end
 
+      # TODO
+      #def get_next_id_command(instance_ops: INSTANCE_OPS,global_ops: GLOBAL_OPS)
+      #  return get_next_argument('command',expected: command_list)
+      #end
+
+      # For create and delete operations: execute one actin or multiple if bulk is yes
+      # @param params either single id or hash, or array for bulk
+      # @param success_msg deleted or created
+      def do_bulk_operation(single_or_array,success_msg,id_result: 'id',fields: :default)
+        raise 'programming error: missing block' unless block_given?
+        params = options.get_option(:bulk) ? single_or_array : [single_or_array]
+        raise 'expecting Array for bulk operation' unless params.is_a?(Array)
+        Log.log.warn('Empty list given for bulk operation') if params.empty?
+        Log.dump(:bulk_create,params)
+        result_list = []
+        params.each do |param|
+          # init for delete
+          result = {id_result => param}
+          begin
+            # execute custom code
+            res = yield(param)
+            # if block returns a hash, let's use this (create)
+            result = res if param.is_a?(Hash)
+            result['status'] = success_msg
+          rescue StandardError => e
+            result['status'] = e.to_s
+          end
+          result_list.push(result)
+        end
+        display_fields = [id_result,'status']
+        if options.get_option(:bulk)
+          return {type: :object_list,data: result_list,fields: display_fields}
+        else
+          display_fields = fields unless fields.eql?(:default)
+          return {type: :single_object,data: result_list.first,fields: display_fields}
+        end
+      end
+
       # @param command [Symbol] command to execute: create show list modify delete
       # @param rest_api [Rest] api to use
       # @param res_class_path [String] sub path in URL to resource relative to base url
       # @param display_fields [Array] fields to display by default
       # @param id_default [String] default identifier to use for existing entity commands (show, modify)
-      # @param use_subkey [bool] true if the result is in a subkey of the json
-      def entity_command(command,rest_api,res_class_path,display_fields: nil,id_default: nil,use_subkey: false)
+      # @param item_list_key [String] result is in a subkey of the json
+      # @return result suitable for CLI result
+      def entity_command(command,rest_api,res_class_path,display_fields: nil,id_default: nil,item_list_key: false)
         if INSTANCE_OPS.include?(command)
           begin
-            one_res_id=instance_identifier()
+            one_res_id = instance_identifier
           rescue StandardError => e
             raise e if id_default.nil?
-            one_res_id=id_default
+            one_res_id = id_default
           end
-          one_res_path="#{res_class_path}/#{one_res_id}"
+          one_res_path = "#{res_class_path}/#{one_res_id}"
         end
         # parameters mandatory for create/modify
-        if [:create,:modify].include?(command)
-          parameters=options.get_option(:value,:mandatory)
+        if %i[create modify].include?(command)
+          parameters = options.get_option(:value,is_type: :mandatory)
         end
         # parameters optional for list
         if [:list].include?(command)
-          parameters=options.get_option(:value,:optional)
+          parameters = options.get_option(:value)
         end
         case command
         when :create
-          return {type: :single_object, data: rest_api.create(res_class_path,parameters)[:data], fields: display_fields}
+          return do_bulk_operation(parameters,'created',fields: display_fields) do |params|
+            raise 'expecting Hash' unless params.is_a?(Hash)
+            rest_api.create(res_class_path,params)[:data]
+          end
+        when :delete
+          return do_bulk_operation(one_res_id,'deleted') do |one_id|
+            rest_api.delete("#{res_class_path}/#{one_id}")
+            {'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,parameters)
-          data=resp[:data]
+          resp = rest_api.read(res_class_path,parameters)
+          data = resp[:data]
           # TODO: not generic : which application is this for ?
           if resp[:http]['Content-Type'].start_with?('application/vnd.api+json')
-            data=data[res_class_path]
+            data = data[res_class_path]
+          end
+          if item_list_key
+            item_list=data[item_list_key]
+            total_count=data['total_count']
+            if !total_count.nil?
+              count_msg = "Items: #{item_list.length}/#{total_count}"
+              count_msg = count_msg.bg_red unless item_list.length.eql?(total_count.to_i)
+              self.format.display_status(count_msg)
+            end
+            data = item_list
           end
-          data=data[res_class_path] if use_subkey
           return {type: :object_list, data: data, fields: display_fields}
         when :modify
-          property=options.get_option(:property,:optional)
-          parameters={property => parameters} unless property.nil?
+          property = options.get_option(:property)
+          parameters = {property => parameters} unless property.nil?
           rest_api.update(one_res_path,parameters)
           return Main.result_status('modified')
-        when :delete
-          rest_api.delete(one_res_path)
-          return Main.result_status('deleted')
         else
           raise "unknown action: #{command}"
         end
@@ -95,11 +154,11 @@ module Aspera
       # implement generic rest operations on given resource path
       def entity_action(rest_api,res_class_path,**opts)
         #res_name=res_class_path.gsub(%r{^.*/},'').gsub(%r{s$},'').gsub('_',' ')
-        command=options.get_next_command(ALL_OPS)
+        command = options.get_next_command(ALL_OPS)
         return entity_command(command,rest_api,res_class_path,**opts)
       end
 
-      # shortcuts for plugin environment
+      # shortcuts helpers for plugin environment
       def options; return @agents[:options];end
 
       def transfer; return @agents[:transfer];end