aspera-cli 4.25.6 → 4.26.0

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

@@ -143,12 +143,12 @@ module Aspera
 
         SPECIAL_ACTIONS = %i[health events info slash license].freeze
 
-        # actions available in v3 in gen4
-        V3_IN_V4_ACTIONS = %i[access_keys].concat(BASE_ACTIONS).concat(SPECIAL_ACTIONS).freeze
-
-        # actions used commonly when a node is involved
+        # commands for : `execute_simple_common`: actions used commonly when a node is involved
         COMMON_ACTIONS = %i[access_keys].concat(BASE_ACTIONS).concat(SPECIAL_ACTIONS).freeze
 
+        # actions available in v3 in gen4
+        V3_IN_V4_ACTIONS = %i[transfer].concat(COMMON_ACTIONS).freeze
+
         private_constant :CENTRAL_SOAP_API_TEST, :SEARCH_REMOVE_FIELDS, :BASE_ACTIONS, :SPECIAL_ACTIONS, :V3_IN_V4_ACTIONS, :COMMON_ACTIONS
 
         # used in aoc
@@ -162,6 +162,7 @@ module Aspera
         COMMANDS_SHARES = (BASE_ACTIONS - %i[search]).freeze
         COMMANDS_FASPEX = COMMON_ACTIONS
 
+        # `browse` display fields for gen4
         GEN4_LS_FIELDS = %w[name type recursive_size size modified_time access_level].freeze
 
         # @param api [Rest] an existing API object for the Node API
@@ -397,9 +398,9 @@ module Aspera
           when *COMMANDS_GEN3
             execute_command_gen3(command)
           when :access_keys
-            ak_command = options.get_next_command(%i[do set_bearer_key].concat(ALL_OPS))
+            ak_command = options.get_next_command(%i[do set_bearer_key].concat(Operations::ALL))
             case ak_command
-            when *ALL_OPS
+            when *Operations::ALL
               return entity_execute(
                 api: @api_node,
                 entity: 'access_keys',
@@ -476,14 +477,14 @@ module Aspera
         end
 
         # Allows to specify a file by its path or by its id on the node in command line
-        # @return [Hash] api and main file id for given path or id in next argument
+        # @return [NodeFileId] api and main file id for given path or id in next argument
         def apifid_from_next_arg(top_file_id)
-          file_path = instance_identifier(description: 'path or %id:<id> or %id:') do |attribute, value|
+          file_path = options.instance_identifier(description: 'path or %id:<id> or %id:') do |attribute, value|
             raise BadArgument, 'Only selection "id" is supported (file id)' unless attribute.eql?('id')
-            # directly return result for method
-            return {api: @api_node, file_id: value}
+            # Directly return result for method
+            return Api::NodeFileId.new(@api_node, value)
           end
-          # there was no selector, so it is a path
+          # There was no selector, so it is a path
           return @api_node.resolve_api_fid(top_file_id, file_path)
         end
 
@@ -497,40 +498,37 @@ module Aspera
             command_legacy = options.get_next_command(V3_IN_V4_ACTIONS)
             # TODO: shall we support all methods here ? what if there is a link ?
             apifid = @api_node.resolve_api_fid(top_file_id, '')
-            return Node.new(context: context, api: apifid[:api]).execute_action(command_legacy)
+            return Node.new(context: context, api: apifid.node_api).execute_action(command_legacy)
           when :node_info, :bearer_token_node
             apifid = apifid_from_next_arg(top_file_id)
             result = {
-              url:     apifid[:api].base_url,
-              root_id: apifid[:file_id]
+              url:     apifid.node_api.base_url,
+              root_id: apifid.file_id
             }
-            Aspera.assert_values(apifid[:api].auth_params[:type], %i[basic oauth2])
-            case apifid[:api].auth_params[:type]
+            case apifid.node_api.auth_params[:type]
             when :basic
-              result[:username] = apifid[:api].auth_params[:username]
-              result[:password] = apifid[:api].auth_params[:password]
+              result[:username] = apifid.node_api.auth_params[:username]
+              result[:password] = apifid.node_api.auth_params[:password]
             when :oauth2
-              result[:username] = apifid[:api].params[:headers][Api::Node::HEADER_X_ASPERA_ACCESS_KEY]
-              result[:password] = apifid[:api].oauth.authorization
-            else Aspera.error_unreachable_line
+              result[:username] = apifid.node_api.params[:headers][Api::Node::HEADER_X_ASPERA_ACCESS_KEY]
+              result[:password] = apifid.node_api.oauth.authorization
+            else Aspera.error_unexpected_value(apifid.node_api.auth_params[:type]){'Node API Auth type'}
             end
             return Main.result_single_object(result) if command_repo.eql?(:node_info)
             Log.dump(:result, result)
-            raise BadArgument, "Cannot get bearer token if authenticating with secret (#{apifid[:api].auth_params[:type]})" unless apifid[:api].auth_params[:type].eql?(:oauth2)
+            raise BadArgument, "Cannot get bearer token if authenticating with secret (#{apifid.node_api.auth_params[:type]})" unless apifid.node_api.auth_params[:type].eql?(:oauth2)
             Aspera.assert(OAuth::Factory.bearer_auth?(result[:password])){'Not using bearer token auth'}
             return Main.result_text(result[:password])
           when :browse
             apifid = apifid_from_next_arg(top_file_id)
-            file_info = apifid[:api].read("files/#{apifid[:file_id]}", headers: Api::Node.add_cache_control)
-            unless file_info['type'].eql?('folder')
-              # a single file
-              return Main.result_object_list([file_info], fields: GEN4_LS_FIELDS)
-            end
-            return Main.result_object_list(apifid[:api].list_files(apifid[:file_id], query: query_read_delete), fields: GEN4_LS_FIELDS)
+            file_info = apifid.node_api.read("files/#{apifid.file_id}", headers: Api::Node.add_cache_control)
+            # a single file
+            return Main.result_object_list([file_info], fields: GEN4_LS_FIELDS) unless file_info['type'].eql?('folder')
+            return Main.result_object_list(apifid.node_api.list_files(apifid.file_id, query: query_read_delete), fields: GEN4_LS_FIELDS)
           when :find
             apifid = apifid_from_next_arg(top_file_id)
             find_lambda = Api::Node.file_matcher_from_argument(options)
-            return Main.result_object_list(@api_node.find_files(apifid[:file_id], find_lambda), fields: ['path'])
+            return Main.result_object_list(@api_node.find_files(apifid.file_id, find_lambda), fields: ['path'])
           when :mkdir, :mklink, :mkfile
             containing_folder_path, new_item = Api::Node.split_folder(options.get_next_argument('path'))
             apifid = @api_node.resolve_api_fid(top_file_id, containing_folder_path, true)
@@ -542,12 +540,12 @@ module Aspera
               target = query.delete('target')
               if target
                 target_apifid = @api_node.resolve_api_fid(top_file_id, target, true)
-                payload[:target_id] = target_apifid[:file_id]
+                payload[:target_id] = target_apifid.file_id
               end
               payload.merge!(query.symbolize_keys)
             end
             if check_exists
-              folder_content = apifid[:api].read("files/#{apifid[:file_id]}/files")
+              folder_content = apifid.node_api.read("files/#{apifid.file_id}/files")
               link_name = ".#{new_item}.asp-lnk"
               found = folder_content.find{ |i| i['name'].eql?(new_item) || i['name'].eql?(link_name)}
               raise "A #{found['type']} already exists with name #{new_item}" if found
@@ -563,26 +561,23 @@ module Aspera
               payload[:type] = :file
               payload[:contents] = Base64.strict_encode64(options.get_next_argument('contents'))
             end
-            result = apifid[:api].create("files/#{apifid[:file_id]}/files", payload)
+            result = apifid.node_api.create("files/#{apifid.file_id}/files", payload)
             return Main.result_single_object(result)
           when :rename
             file_path = options.get_next_argument('source path')
             apifid = @api_node.resolve_api_fid(top_file_id, file_path)
             newname = options.get_next_argument('new name')
-            result = apifid[:api].update("files/#{apifid[:file_id]}", {name: newname})
+            result = apifid.node_api.update("files/#{apifid.file_id}", {name: newname})
             return Main.result_status("renamed to #{newname}")
           when :delete
             return do_bulk_operation(command: command_repo, descr: 'path', values: String, id_result: 'path') do |l_path|
-              apifid = if (m = Base.percent_selector(l_path))
+              apifid = if (m = Manager.percent_selector(l_path))
                 Aspera.assert_values(m[:field], ['id'], type: BadIdentifier)
-                {
-                  api:     @api_node,
-                  file_id: m[:value]
-                }
+                Api::NodeFileId.new(@api_node, m[:value])
               else
                 @api_node.resolve_api_fid(top_file_id, l_path)
               end
-              result = apifid[:api].delete("files/#{apifid[:file_id]}")
+              result = apifid.node_api.delete("files/#{apifid.file_id}")
               {'path' => l_path}
             end
           when :sync
@@ -596,66 +591,67 @@ module Aspera
               end
               # remote is specified by option: `to_folder`
               apifid = @api_node.resolve_api_fid(top_file_id, remote_path)
-              apifid[:api].transfer_spec_gen4(apifid[:file_id], ts_direction)
+              apifid.node_api.transfer_spec_gen4(apifid.file_id, ts_direction)
             end
           when :upload
             apifid = @api_node.resolve_api_fid(top_file_id, transfer.destination_folder(Transfer::Spec::DIRECTION_SEND), true)
-            return Main.result_transfer(transfer.start(apifid[:api].transfer_spec_gen4(apifid[:file_id], Transfer::Spec::DIRECTION_SEND)))
+            return Main.result_transfer(transfer.start(apifid.node_api.transfer_spec_gen4(apifid.file_id, Transfer::Spec::DIRECTION_SEND)))
           when :download
             apifid, source_paths = @api_node.resolve_api_fid_paths(top_file_id, transfer.ts_source_paths)
-            return Main.result_transfer(transfer.start(apifid[:api].transfer_spec_gen4(apifid[:file_id], Transfer::Spec::DIRECTION_RECEIVE, {'paths'=>source_paths})))
+            return Main.result_transfer(transfer.start(apifid.node_api.transfer_spec_gen4(apifid.file_id, Transfer::Spec::DIRECTION_RECEIVE, {'paths'=>source_paths})))
           when :cat
             apifid = apifid_from_next_arg(top_file_id)
-            http = apifid[:api].read("files/#{apifid[:file_id]}/content", ret: :resp)
+            http = apifid.node_api.read("files/#{apifid.file_id}/content", ret: :resp)
             return Main.result_text(http.body)
           when :show
             apifid = apifid_from_next_arg(top_file_id)
-            items = apifid[:api].read("files/#{apifid[:file_id]}")
+            items = apifid.node_api.read("files/#{apifid.file_id}")
             return Main.result_single_object(items)
           when :modify
             apifid = apifid_from_next_arg(top_file_id)
             update_param = options.get_next_argument('update data', validation: Hash)
-            apifid[:api].update("files/#{apifid[:file_id]}", update_param)
+            apifid.node_api.update("files/#{apifid.file_id}", update_param)
             return Main.result_status('Done')
           when :thumbnail
             apifid = apifid_from_next_arg(top_file_id)
-            http = apifid[:api].read("files/#{apifid[:file_id]}/preview", headers: {'Accept' => 'image/png'}, ret: :resp)
+            http = apifid.node_api.read("files/#{apifid.file_id}/preview", headers: {'Accept' => 'image/png'}, ret: :resp)
             return Main.result_image(http.body)
           when :permission
             apifid = apifid_from_next_arg(top_file_id)
-            command_perm = options.get_next_command(%i[list show create delete])
+            command_perm = options.get_next_command(%i[list show create delete modify])
             case command_perm
+            when :modify
+              apifid.node_api.update("permissions/#{options.instance_identifier}", value_create_modify(command: 'permission modify'))
+              return Main.result_status('Updated')
             when :list
               list_query = query_read_delete(default: Rest.php_style({'include' => %w[access_level permission_count]}))
-              # specify file to get permissions for unless not specified
-              list_query['file_id'] = apifid[:file_id] unless apifid[:file_id].to_s.empty?
+              # Specify file to get permissions for unless not specified (then, get all permissions)
+              list_query['file_id'] = apifid.file_id unless apifid.file_id.to_s.empty?
               list_query['inherited'] = false if list_query.key?('file_id') && !list_query.key?('inherited')
-              # NOTE: supports per_page and page and header X-Total-Count
-              items = apifid[:api].read('permissions', list_query)
+              items = apifid.node_api.read_with_pages('permissions', list_query)
               return Main.result_object_list(items)
             when :show
-              perm_id = instance_identifier
-              return Main.result_single_object(apifid[:api].read("permissions/#{perm_id}"))
+              return Main.result_single_object(apifid.node_api.read("permissions/#{options.instance_identifier}"))
             when :delete
               return do_bulk_operation(command: command_perm, values: :identifier) do |one_id|
-                apifid[:api].delete("permissions/#{one_id}")
+                apifid.node_api.delete("permissions/#{one_id}")
                 # notify application of deletion
-                the_app = apifid[:api].app_info
-                the_app&.[](:api)&.permissions_send_event(event_data: {}, app_info: the_app, types: ['permission.deleted'])
+                the_app = apifid.node_api.app_info
+                the_app&.api&.permissions_send_event(event_data: {}, app_info: the_app, types: ['permission.deleted'])
                 {'id' => one_id}
               end
             when :create
               create_param = options.get_next_argument('creation data', validation: Hash)
               raise Cli::BadArgument, 'no file_id' if create_param.key?('file_id')
-              create_param['file_id'] = apifid[:file_id]
+              create_param['file_id'] = apifid.file_id
               create_param['access_levels'] = Api::Node::ACCESS_LEVELS unless create_param.key?('access_levels')
               # add application specific tags (AoC)
-              the_app = apifid[:api].app_info
-              the_app&.[](:api)&.permissions_set_create_params(perm_data: create_param, app_info: the_app)
+              the_app = apifid.node_api.app_info
+              the_app&.api&.permissions_set_create_params(perm_data: create_param, app_info: the_app)
               # create permission
-              created_data = apifid[:api].create('permissions', create_param)
+              created_data = apifid.node_api.create('permissions', create_param)
               # notify application of creation
-              the_app&.[](:api)&.permissions_send_event(event_data: created_data, app_info: the_app)
+              the_app&.api&.permissions_send_event(event_data: created_data, app_info: the_app)
               return Main.result_single_object(created_data)
             else Aspera.error_unreachable_line
             end
@@ -682,7 +678,7 @@ module Aspera
         def execute_async
           command = options.get_next_command(%i[list delete files show counters bandwidth])
           unless command.eql?(:list)
-            async_id = instance_identifier{ |field, value| async_lookup(field, value)}
+            async_id = options.instance_identifier{ |field, value| async_lookup(field, value)}
             if async_id.eql?(SpecialValues::ALL)
               raise Cli::BadArgument, 'ALL only for show and delete' unless %i[show delete].include?(command)
               async_ids = @api_node.read('async/list')['sync_ids']
@@ -770,7 +766,7 @@ module Aspera
           res_class_path = 'v3/watchfolders'
           command = options.get_next_command(WATCH_FOLDER_MUL + WATCH_FOLDER_SING)
           if WATCH_FOLDER_SING.include?(command)
-            one_res_id = instance_identifier
+            one_res_id = options.instance_identifier
             one_res_path = "#{res_class_path}/#{one_res_id}"
           end
           # hum, to avoid: Unable to convert 2016_09_14 configuration
@@ -818,9 +814,9 @@ module Aspera
           when :async then return execute_async # former API
           when :ssync
             # Node API: /asyncs (newer)
-            sync_command = options.get_next_command(%i[start stop bandwidth counters files state summary] + ALL_OPS - %i[modify])
+            sync_command = options.get_next_command(%i[start stop bandwidth counters files state summary] + Operations::ALL - %i[modify])
             case sync_command
-            when *ALL_OPS
+            when *Operations::ALL
               return entity_execute(
                 api: @api_node,
                 entity: :asyncs,
@@ -828,7 +824,7 @@ module Aspera
                 items_key: 'ids'
               ){ |field, value| ssync_lookup(field, value)}
             else
-              asyncs_id = instance_identifier{ |field, value| ssync_lookup(field, value)}
+              asyncs_id = options.instance_identifier{ |field, value| ssync_lookup(field, value)}
               if %i[start stop].include?(sync_command)
                 @api_node.call(
                   operation:    'POST',
@@ -900,13 +896,13 @@ module Aspera
               end
               return Main.result_object_list(sessions, fields: %w[id status start_time end_time target_rate_kbps])
             when :cancel
-              @api_node.cancel("ops/transfers/#{instance_identifier}")
+              @api_node.cancel("ops/transfers/#{options.instance_identifier}")
               return Main.result_status('Cancelled')
             when :show
-              resp = @api_node.read("ops/transfers/#{instance_identifier}")
+              resp = @api_node.read("ops/transfers/#{options.instance_identifier}")
               return Main.result_single_object(resp)
             when :modify
-              @api_node.update("ops/transfers/#{instance_identifier}", options.get_next_argument('update value', validation: Hash))
+              @api_node.update("ops/transfers/#{options.instance_identifier}", options.get_next_argument('update value', validation: Hash))
               return Main.result_status('Modified')
             when :bandwidth_average
               transfers_data = @api_node.read('ops/transfers', query_read_delete)
@@ -955,7 +951,7 @@ module Aspera
             end
           when :service
             command = options.get_next_command(%i[list create delete])
-            service_id = instance_identifier if [:delete].include?(command)
+            service_id = options.instance_identifier if [:delete].include?(command)
             case command
             when :list
               resp = @api_node.read('rund/services')

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

@@ -8,21 +8,14 @@ module Aspera
       # base class for applications supporting OAuth 2.0 authentication
       class Oauth < BasicAuth
         class << self
-          # Get command line options specified by `AUTH_OPTIONS` and `defaults.keys` (value is default).
-          # Adds those not nil to the `kwargs`.
-          # Instantiate the provided `klass` with those `kwargs`.
-          # `defaults` can specify a default value (not `nil`)
-          # @param options  [Cli::Manager] Object to get command line options.
-          # @param kwargs   [Hash]  Object creation arguments
-          # @param defaults [Hash]  Additional options, key=symbol, value=default value or nil
-          # @return [Object] instance of `klass`
+          # Get command line `options` specified by `AUTH_OPTIONS`
+          # @param options [Cli::Manager] Object to get command line options.
+          # @return [Hash{Symbol => Object}] Options
           # @raise [Cli::Error] if a required option is missing
-          def args_from_options(options, defaults: nil, **kwargs)
-            defaults ||= {}
-            (AUTH_OPTIONS + defaults.keys).each_with_object(kwargs) do |i, m|
+          def kwargs_from_options(options)
+            AUTH_OPTIONS.each_with_object({}) do |i, m|
               v = options.get_option(i)
               m[i] = v unless v.nil?
-              m[i] = defaults[i] if m[i].nil? && !defaults[i].nil?
             end
           rescue ::ArgumentError => e
             if (m = e.message.match(/missing keyword: :(.*)$/))

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

@@ -169,7 +169,7 @@ module Aspera
                 data: nil
               }
               call_params = {format: :json}
-              wf_id = instance_identifier
+              wf_id = options.instance_identifier
               # get external parameters if any
               options.get_next_argument('external_parameters', mandatory: false, validation: Hash, default: {}).each do |name, value|
                 call_params["external_parameters[#{name}]"] = value
@@ -192,28 +192,28 @@ module Aspera
               return result
             # 3. Fetch input specification for a workflow
             when :inputs
-              result = call_ao("workflow_inputs_spec/#{instance_identifier}")
+              result = call_ao("workflow_inputs_spec/#{options.instance_identifier}")
               return Main.result_single_object(result['workflow_inputs_spec'])
             # 4. Check the running status for all workflows
             # 5. Check the running status for a particular workflow
             when :status
-              wf_id = instance_identifier
+              wf_id = options.instance_identifier
               result = call_ao(wf_id.eql?(SpecialValues::ALL) ? 'workflows_status' : "workflows_status/#{wf_id}")
               return Main.result_object_list(result['workflows']['workflow'])
             # 6. Check the detailed running status for a particular workflow
             when :details
-              result = call_ao("workflow_details/#{instance_identifier}")
+              result = call_ao("workflow_details/#{options.instance_identifier}")
               return Main.result_object_list(result['workflows']['workflow']['statuses'])
             # 15. Fetch output specification for a particular work flow
             when :outputs
-              result = call_ao("workflow_outputs_spec/#{instance_identifier}")
+              result = call_ao("workflow_outputs_spec/#{options.instance_identifier}")
               return Main.result_object_list(result['workflow_outputs_spec']['output'])
             # 19.Fetch all workorders from a workflow
             when :workorders
-              result = call_ao("work_orders_list/#{instance_identifier}")
+              result = call_ao("work_orders_list/#{options.instance_identifier}")
               return Main.result_object_list(result['work_orders'])
             when :export
-              result = call_ao("export_workflow/#{instance_identifier}", format: nil, http: true)
+              result = call_ao("export_workflow/#{options.instance_identifier}", format: nil, http: true)
               return Main.result_text(result.body)
             end
           when :workorders
@@ -221,22 +221,22 @@ module Aspera
             case command
             # 7. Check the status for a particular work order
             when :status
-              wo_id = instance_identifier
+              wo_id = options.instance_identifier
               result = call_ao("work_order_status/#{wo_id}")
               return Main.result_single_object(result['work_order'])
             # 9. Cancel a Work Order
             when :cancel
-              wo_id = instance_identifier
+              wo_id = options.instance_identifier
               result = call_ao("work_order_cancel/#{wo_id}")
               return Main.result_single_object(result['work_order'])
             # 11. Reset a Work order
             when :reset
-              wo_id = instance_identifier
+              wo_id = options.instance_identifier
               result = call_ao("work_order_reset/#{wo_id}")
               return Main.result_single_object(result['work_order'])
             # 16. Fetch output of a work order
             when :output
-              wo_id = instance_identifier
+              wo_id = options.instance_identifier
               result = call_ao("work_order_output/#{wo_id}", format: 'xml')
               return Main.result_object_list(result['variable'])
             end
@@ -245,12 +245,12 @@ module Aspera
             case command
             # 8. Check the status of a Step
             when :status
-              ws_id = instance_identifier
+              ws_id = options.instance_identifier
               result = call_ao("work_step_status/#{ws_id}")
               return Main.result_single_object(result)
             # 10. Cancel a Work Step
             when :cancel
-              ws_id = instance_identifier
+              ws_id = options.instance_identifier
               result = call_ao("work_step_cancel/#{ws_id}")
               return Main.result_single_object(result)
             end