aspera-cli 4.26.0 → 4.26.2

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

@@ -89,27 +89,27 @@ module Aspera
               end
             end
             res = ats_api.create('access_keys', params)
-            return Main.result_single_object(res)
+            return Result::SingleObject.new(res)
             # TODO : action : modify, with "PUT"
           when :list
             params = query_read_delete(default: {'offset' => 0, 'max_results' => 1000})
             res = ats_api.read('access_keys', params)
-            return Main.result_object_list(res['data'], fields: ['name', 'id', 'created.at', 'modified.at'])
+            return Result::ObjectList.new(res['data'], fields: ['name', 'id', 'created.at', 'modified.at'])
           when :show
             res = ats_api.read("access_keys/#{access_key_id}")
-            return Main.result_single_object(res)
+            return Result::SingleObject.new(res)
           when :modify
             params = value_create_modify(command: command)
             params['id'] = access_key_id
             ats_api.update("access_keys/#{access_key_id}", params)
-            return Main.result_status('modified')
+            return Result::Status.new('modified')
           when :entitlement
             ak = ats_api.read("access_keys/#{access_key_id}")
             api_bss = Api::Alee.new(ak['license']['entitlement_id'], ak['license']['customer_id'])
-            return Main.result_single_object(api_bss.read('entitlement'))
+            return Result::SingleObject.new(api_bss.read('entitlement'))
           when :delete
             ats_api.delete("access_keys/#{access_key_id}")
-            return Main.result_status("deleted #{access_key_id}")
+            return Result::Status.new("deleted #{access_key_id}")
           when :node
             ak_data = ats_api.read("access_keys/#{access_key_id}")
             server_data = @ats_api_open.all_servers.find{ |i| i['id'].start_with?(ak_data['transfer_server_id'])}
@@ -135,7 +135,7 @@ module Aspera
                 password: config.lookup_secret(url: ats_url, username: access_key_id)
               }
             )
-            return Main.result_single_object(api_ak_auth.read('servers'))
+            return Result::SingleObject.new(api_ak_auth.read('servers'))
           else Aspera.error_unexpected_value(command)
           end
         end
@@ -144,9 +144,9 @@ module Aspera
           command = options.get_next_command(%i[clouds list show])
           case command
           when :clouds
-            return Main.result_object_list(@ats_api_open.cloud_names.map{ |k, v| CLOUD_TABLE.zip([k, v]).to_h})
+            return Result::ObjectList.new(@ats_api_open.cloud_names.map{ |k, v| CLOUD_TABLE.zip([k, v]).to_h})
           when :list
-            return Main.result_object_list(@ats_api_open.all_servers, fields: %w[id cloud region])
+            return Result::ObjectList.new(@ats_api_open.all_servers, fields: %w[id cloud region])
           when :show
             if options.get_option(:cloud) || options.get_option(:region)
               server_data = server_by_cloud_region
@@ -155,7 +155,7 @@ module Aspera
               server_data = @ats_api_open.all_servers.find{ |i| i['id'].eql?(server_id)}
               raise BadIdentifier.new('server', server_id) if server_data.nil?
             end
-            return Main.result_single_object(server_data)
+            return Result::SingleObject.new(server_data)
           end
         end
 
@@ -195,19 +195,19 @@ module Aspera
           when :instances
             instances = ats_ibm_api.read('instances')
             Log.log.warn{"more instances remaining: #{instances['remaining']}"} unless instances['remaining'].to_i.eql?(0)
-            return Main.result_value_list(instances['data'], name: 'instance')
+            return Result::ValueList.new(instances['data'], name: 'instance')
           when :create
             created_key = ats_ibm_api.create('api_keys', value_create_modify(command: command, default: {}))
-            return Main.result_single_object(created_key)
+            return Result::SingleObject.new(created_key)
           when :list # list known api keys in ATS (this require an api_key ...)
             res = ats_ibm_api.read('api_keys', {'offset' => 0, 'max_results' => 1000})
-            return Main.result_value_list(res['data'], name: 'ats_id')
+            return Result::ValueList.new(res['data'], name: 'ats_id')
           when :show # show one of api_key in ATS
             res = ats_ibm_api.read("api_keys/#{concerned_id}")
-            return Main.result_single_object(res)
+            return Result::SingleObject.new(res)
           when :delete
             ats_ibm_api.delete("api_keys/#{concerned_id}")
-            return Main.result_status("deleted #{concerned_id}")
+            return Result::Status.new("deleted #{concerned_id}")
           else Aspera.error_unexpected_value(command)
           end
         end
@@ -228,7 +228,7 @@ module Aspera
             return execute_action_api_key
           when :aws_trust_policy
             res = ats_api.read('aws/trustpolicy', {region: options.get_option(:region, mandatory: true)})
-            return Main.result_single_object(res)
+            return Result::SingleObject.new(res)
           else Aspera.error_unexpected_value(command)
           end
         end

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

@@ -2,6 +2,7 @@
 
 require 'aspera/cli/extended_value'
 require 'aspera/assert'
+require 'aspera/cli/result'
 
 module Aspera
   module Cli
@@ -37,16 +38,20 @@ module Aspera
         # Global objects
         attr_reader :context
 
-        # @return [Manager]
+        # @return [Aspera::Cli::Manager]
         def options; @context.options; end
-        # @return [TransferAgent]
+        # @return [Aspera::Cli::TransferAgent]
         def transfer; @context.transfer; end
-        # @return [Config]
+        # @return [Aspera::Cli::Plugins::Config]
         def config; @context.config; end
-        # @return [Formatter]
+        # @return [Aspera::Cli::Formatter]
         def formatter; @context.formatter; end
-        # @return [PersistencyFolder]
+        # @return [Aspera::PersistencyFolder]
         def persistency; @context.persistency; end
+        # @return [Aspera::Cli::PresetManager]
+        def presets; @context.presets; end
+        # @return [Aspera::Cli::Http]
+        def http_config; @context.http_config; end
 
         def add_manual_header(has_options = true)
           # Manual header for all plugins
@@ -57,20 +62,23 @@ module Aspera
         end
 
         # For create and delete operations: execute one action or multiple if bulk is yes
-        # @param command   [Symbol] Operation: :create, :delete, ...
-        # @param descr     [String] Description of the value
-        # @param values    [Object] Value(s), or type of value to get from user
-        # @param id_result [String] Key in result hash to use as identifier
-        # @param fields    [Array]  Fields to display
-        # @param block     [Proc]   Block to execute for each value
-        def do_bulk_operation(command:, descr: nil, values: Hash, id_result: 'id', fields: :default, &block)
-          Aspera.assert(block_given?){'missing block'}
+        # @param command [Symbol] Operation: :create, :delete, ...
+        # @param descr [String, nil] Description of the value
+        # @param values [Class, Array, Symbol] Type, or list of values, or :identifier, result is given to the block in loop
+        # @param id_result [String] Key in result Hash to use as identifier
+        # @param fields [Symbol, Array] Fields to display
+        # @param schema [Hash, nil] JSON schema for validation
+        # @yieldparam param [Object] The parameter value to process
+        # @yieldreturn [Hash, nil] Result hash for the operation (optional)
+        # @return [Hash] Result suitable for CLI output
+        def do_bulk_operation(command:, descr: nil, values: Hash, id_result: 'id', fields: :default, schema: nil, &block)
+          Aspera.assert(block_given?, 'missing block')
           is_bulk = options.get_option(:bulk)
           case values
           when :identifier
             values = options.instance_identifier(description: descr)
           when Class
-            values = value_create_modify(command: command, description: descr, type: values, bulk: is_bulk)
+            values = value_create_modify(command: command, description: descr, type: values, bulk: is_bulk, schema: schema)
           end
           # If not bulk, there is a single value
           params = is_bulk ? values : [values]
@@ -97,23 +105,25 @@ module Aspera
           end
           display_fields = [id_result, 'status']
           if is_bulk
-            return Main.result_object_list(result_list, fields: display_fields)
+            return Result::ObjectList.new(result_list, fields: display_fields)
           else
             display_fields = fields unless fields.eql?(:default)
-            return Main.result_single_object(result_list.first, fields: display_fields)
+            return Result::SingleObject.new(result_list.first, fields: display_fields)
           end
         end
 
         # Operations: Create, Delete, Show, List, Modify
-        # @param api            [Rest]    api to use
-        # @param entity         [String]  sub path in URL to resource relative to base url
-        # @param command        [Symbol]  command to execute: create show list modify delete
-        # @param display_fields [Array]   fields to display by default
-        # @param items_key      [String]  result is in a sub key of the json
-        # @param delete_style   [String]  If set, the delete operation by array in payload
-        # @param id_as_arg      [String]  If set, the id is provided as url argument ?<id_as_arg>=<id>
-        # @param is_singleton   [Boolean] If `true`, entity is the full path to the resource
-        # @param &block         [Proc]    Block to search for identifier based on attribute value
+        # @param api [Aspera::Rest] API to use
+        # @param entity [String] Sub path in URL to resource relative to base url
+        # @param command [Symbol, nil] Command to execute: :create, :show, :list, :modify, :delete
+        # @param display_fields [Array, nil] Fields to display by default
+        # @param items_key [String, nil] Result is in a sub key of the JSON
+        # @param delete_style [String, nil] If set, the delete operation by array in payload
+        # @param id_as_arg [Boolean, String] If set, the id is provided as url argument ?<id_as_arg>=<id>
+        # @param is_singleton [Boolean] If `true`, entity is the full path to the resource
+        # @param list_query [Hash, nil] Query parameters for list operation
+        # @yieldparam value [String] Value to search for identifier
+        # @yieldreturn [String] The identifier
         # @return [Hash] Result suitable for CLI result
         def entity_execute(
           api:,
@@ -125,6 +135,7 @@ module Aspera
           id_as_arg: false,
           is_singleton: false,
           list_query: nil,
+          schema: nil,
           &block
         )
           command = options.get_next_command(Operations::ALL) if command.nil?
@@ -139,7 +150,7 @@ module Aspera
           case command
           when :create
             raise BadArgument, 'cannot create singleton' if is_singleton
-            return do_bulk_operation(command: command, descr: 'data', fields: display_fields) do |params|
+            return do_bulk_operation(command: command, descr: 'data', fields: display_fields, schema: schema) do |params|
               api.create(entity, params)
             end
           when :delete
@@ -153,17 +164,17 @@ module Aspera
                 content_type: Mime::JSON,
                 body:         {delete_style => one_res_id}
               )
-              return Main.result_status('deleted')
+              return Result::Status.new('deleted')
             end
             return do_bulk_operation(command: command, values: one_res_id) do |one_id|
               api.delete("#{entity}/#{one_id}", query_read_delete)
               {'id' => one_id}
             end
           when :show
-            return Main.result_single_object(api.read(one_res_path), fields: display_fields)
+            return Result::SingleObject.new(api.read(one_res_path), fields: display_fields)
           when :list
             data, http = api.read(entity, query_read_delete, ret: :both)
-            return Main.result_empty if http.code == '204'
+            return Result::Empty.new if http.code == '204'
             # TODO: not generic : which application is this for ?
             if http['Content-Type'].start_with?('application/vnd.api+json')
               Log.log.debug('is vnd.api')
@@ -172,23 +183,25 @@ module Aspera
             data = data[items_key] if items_key
             case data
             when Hash
-              return Main.result_single_object(data, fields: display_fields)
+              return Result::SingleObject.new(data, fields: display_fields)
             when Array
-              return Main.result_object_list(data, fields: display_fields) if data.empty? || data.first.is_a?(Hash)
-              return Main.result_value_list(data)
+              return Result::ObjectList.new(data, fields: display_fields) if data.empty? || data.first.is_a?(Hash)
+              return Result::ValueList.new(data)
             else
               Aspera.error_unexpected_value(data.class.name){'list type'}
             end
           when :modify
-            parameters = value_create_modify(command: command)
+            parameters = value_create_modify(command: command, schema: schema)
             api.update(one_res_path, parameters)
-            return Main.result_status('modified')
+            return Result::Status.new('modified')
           else
             Aspera.error_unexpected_value(command){'command'}
           end
         end
 
         # Query parameters in URL suitable for REST: list/`GET` and delete/`DELETE`
+        # @param default [Hash, nil] Default query parameters
+        # @return [Hash, nil] Query parameters
         def query_read_delete(default: nil)
           # Dup default, as it could be frozen
           query = options.get_option(:query) || default.dup
@@ -202,27 +215,29 @@ module Aspera
           return query
         end
 
-        # Retrieves an extended value from command line, used for creation or modification of entities
-        # @param command [Symbol]  command name for error message
-        # @param type    [Class]   expected type of value, either a Class, an Array of Class
-        # @param bulk    [Boolean] if true, value must be an Array of <type>
-        # @param default [Object]  default value if not provided
-        def value_create_modify(command:, description: nil, type: Hash, bulk: false, default: nil)
+        # Retrieves an extended value from command line.
+        # Used for creation or modification of entities.
+        # @param command [Symbol] Command name for error message
+        # @param description [String, nil] Description of the value
+        # @param type [Class, nil] Expected type of value
+        # @param bulk [Boolean] If `true`, value must be an Array of `type`
+        # @param default [Object, nil] Default value if not provided
+        # @param schema [Hash, nil] JSON schema for validation
+        # @return [Hash, Array<Hash>] The value(s) to create object(s)
+        def value_create_modify(command:, description: nil, type: Hash, bulk: false, default: nil, schema: nil)
           value = options.get_next_argument(
-            "parameters for #{command}#{" (#{description})" unless description.nil?}", mandatory: default.nil?,
-            validation: bulk ? Array : type
+            "parameters for #{command}#{" (#{description})" unless description.nil?}",
+            mandatory: default.nil?,
+            validation: bulk ? Array : type,
+            schema: schema
           )
           value = default if value.nil?
           unless type.nil?
-            type = [type] unless type.is_a?(Array)
-            Aspera.assert_array_all(type, Class){'check types'}
+            Aspera.assert_type(type, Class){'type'}
             if bulk
-              Aspera.assert_type(value, Array, type: Cli::BadArgument)
-              value.each do |v|
-                Aspera.assert_values(v.class, type, type: Cli::BadArgument)
-              end
+              Aspera.assert_array_all(value, type, type: Cli::BadArgument){'type'}
             else
-              Aspera.assert_values(value.class, type, type: Cli::BadArgument)
+              Aspera.assert_type(value, type, type: Cli::BadArgument){'type'}
             end
           end
           return value