aspera-cli 4.11.0 → 4.12.0

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

@@ -1,28 +1,35 @@
 # frozen_string_literal: true
 
+# spellchecker: ignore workgroups,mypackages
+
 require 'aspera/cli/basic_auth_plugin'
 require 'aspera/persistency_action_once'
 require 'aspera/id_generator'
 require 'aspera/nagios'
+require 'aspera/environment'
 require 'securerandom'
+require 'ruby-progressbar'
+require 'tty-spinner'
 
 module Aspera
   module Cli
     module Plugins
       class Faspex5 < Aspera::Cli::BasicAuthPlugin
+        RECIPIENT_TYPES = %w[user workgroup external_user distribution_list shared_inbox].freeze
+        PACKAGE_TERMINATED = %w[completed failed].freeze
+        API_DETECT = 'api/v5/configuration/ping'
         class << self
           def detect(base_url)
             api = Rest.new(base_url: base_url, redirect_max: 1)
-            result = api.read('api/v5/configuration/ping')
+            result = api.read(API_DETECT)
             if result[:http].code.start_with?('2') && result[:http].body.strip.empty?
-              return {version: '5'}
+              return {version: '5', url: result[:http].uri.to_s[0..-(API_DETECT.length + 2)]}
             end
             return nil
           end
         end
 
         TRANSFER_CONNECT = 'connect'
-        private_constant :TRANSFER_CONNECT
 
         def initialize(env)
           super(env)
@@ -32,42 +39,43 @@ module Aspera
           options.add_opt_list(:auth, [:boot].concat(Oauth::STD_AUTH_TYPES), 'OAuth type of authentication')
           options.add_opt_simple(:private_key, 'OAuth JWT RSA private key PEM value (prefix file path with @file:)')
           options.add_opt_simple(:passphrase, 'RSA private key passphrase')
+          options.add_opt_simple(:shared_folder, 'Shared folder source for package files')
           options.set_option(:auth, :jwt)
           options.parse_options!
         end
 
         def set_api
-          @faxpex5_api_base_url = options.get_option(:url, is_type: :mandatory).gsub(%r{/+$}, '')
-          @faxpex5_api_auth_url = "#{@faxpex5_api_base_url}/auth"
-          faxpex5_api_v5_url = "#{@faxpex5_api_base_url}/api/v5"
+          @faspex5_api_base_url = options.get_option(:url, is_type: :mandatory).gsub(%r{/+$}, '')
+          @faspex5_api_auth_url = "#{@faspex5_api_base_url}/auth"
+          faspex5_api_v5_url = "#{@faspex5_api_base_url}/api/v5"
           case options.get_option(:auth, is_type: :mandatory)
           when :boot
             # the password here is the token copied directly from browser in developer mode
             @api_v5 = Rest.new({
-              base_url: faxpex5_api_v5_url,
+              base_url: faspex5_api_v5_url,
               headers:  {'Authorization' => options.get_option(:password, is_type: :mandatory)}
             })
           when :web
             # opens a browser and ask user to auth using web
             @api_v5 = Rest.new({
-              base_url: faxpex5_api_v5_url,
+              base_url: faspex5_api_v5_url,
               auth:     {
-                type:      :oauth2,
-                base_url:  @faxpex5_api_auth_url,
-                crtype:    :web,
-                client_id: options.get_option(:client_id, is_type: :mandatory),
-                web:       {redirect_uri: options.get_option(:redirect_uri, is_type: :mandatory)}
+                type:         :oauth2,
+                base_url:     @faspex5_api_auth_url,
+                grant_method: :web,
+                client_id:    options.get_option(:client_id, is_type: :mandatory),
+                web:          {redirect_uri: options.get_option(:redirect_uri, is_type: :mandatory)}
               }})
           when :jwt
             app_client_id = options.get_option(:client_id, is_type: :mandatory)
             @api_v5 = Rest.new({
-              base_url: faxpex5_api_v5_url,
+              base_url: faspex5_api_v5_url,
               auth:     {
-                type:      :oauth2,
-                base_url:  @faxpex5_api_auth_url,
-                crtype:    :jwt,
-                client_id: app_client_id,
-                jwt:       {
+                type:         :oauth2,
+                base_url:     @faspex5_api_auth_url,
+                grant_method: :jwt,
+                client_id:    app_client_id,
+                jwt:          {
                   payload:         {
                     iss: app_client_id,    # issuer
                     aud: app_client_id,    # audience TODO: ???
@@ -81,18 +89,77 @@ module Aspera
           end
         end
 
-        ACTIONS = %i[health version user bearer_token package admin].freeze
+        def normalize_recipients(parameters)
+          return unless parameters.key?('recipients')
+          raise 'Field recipients must be an Array' unless parameters['recipients'].is_a?(Array)
+          parameters['recipients'] = parameters['recipients'].map do |recipient_data|
+            # if just a string, assume it is the name
+            if recipient_data.is_a?(String)
+              result = @api_v5.read('contacts', {q: recipient_data, context: 'packages', type: [Rest::ARRAY_PARAMS, *RECIPIENT_TYPES]})[:data]
+              raise "No matching contact for #{recipient_data}" if result.empty?
+              raise "Multiple matching contact for #{recipient_data} : #{result['contacts'].map{|i|i['name']}.join(', ')}" unless 1.eql?(result['total_count'])
+              matched = result['contacts'].first
+              recipient_data = {
+                name:           matched['name'],
+                recipient_type: matched['type']
+              }
+            end
+            # result for mapping
+            recipient_data
+          end
+        end
+
+        def wait_for_complete_upload(id)
+          parameters = options.get_option(:value)
+          spinner = nil
+          progress = nil
+          while true
+            status = @api_v5.read("packages/#{id}/upload_details")[:data]
+            # user asked to not follow
+            break unless parameters
+            if status['upload_status'].eql?('submitted')
+              if spinner.nil?
+                spinner = TTY::Spinner.new('[:spinner] :title', format: :classic)
+                spinner.start
+              end
+              spinner.update(title: status['upload_status'])
+              spinner.spin
+            elsif progress.nil?
+              progress = ProgressBar.create(
+                format:     '%a %B %p%% %r Mbps %e',
+                rate_scale: lambda{|rate|rate / Environment::BYTES_PER_MEBIBIT},
+                title:      'progress',
+                total:      status['bytes_total'].to_i)
+            else
+              progress.progress = status['bytes_written'].to_i
+            end
+            break if PACKAGE_TERMINATED.include?(status['upload_status'])
+            sleep(0.5)
+          end
+          status['id'] = id
+          return status
+        end
+
+        def lookup_entity(entity_type, property, value)
+          # TODO: what if too many, use paging ?
+          all = @api_v5.read(entity_type)[:data][entity_type]
+          found = all.find{|i|i[property].eql?(value)}
+          raise "No #{entity_type} with #{property} = #{value}" if found.nil?
+          return found
+        end
+
+        ACTIONS = %i[health version user bearer_token package shared_folders admin gateway postprocessing].freeze
 
         def execute_action
-          set_api
           command = options.get_next_command(ACTIONS)
+          set_api unless command.eql?(:postprocessing)
           case command
           when :version
             return { type: :single_object, data: @api_v5.read('version')[:data] }
           when :health
             nagios = Nagios.new
             begin
-              result = Rest.new(base_url: @faxpex5_api_base_url).read('health')[:data]
+              result = Rest.new(base_url: @faspex5_api_base_url).read('health')[:data]
               result.each do |k, v|
                 nagios.add_ok(k, v.to_s)
               end
@@ -114,7 +181,7 @@ module Aspera
           when :bearer_token
             return {type: :text, data: @api_v5.oauth_token}
           when :package
-            command = options.get_next_command(%i[list show send receive])
+            command = options.get_next_command(%i[list show send receive status])
             case command
             when :list
               parameters = options.get_option(:value)
@@ -126,20 +193,40 @@ module Aspera
             when :show
               id = instance_identifier
               return {type: :single_object, data: @api_v5.read("packages/#{id}")[:data]}
+            when :status
+              status = wait_for_complete_upload(instance_identifier)
+              return {type: :single_object, data: status}
             when :send
               parameters = options.get_option(:value, is_type: :mandatory)
-              raise CliBadArgument, 'value must be hash, refer to API' unless parameters.is_a?(Hash)
+              raise CliBadArgument, 'Value must be Hash, refer to API' unless parameters.is_a?(Hash)
+              normalize_recipients(parameters)
               package = @api_v5.create('packages', parameters)[:data]
-              # TODO: option to send from remote source or httpgw
-              transfer_spec = @api_v5.call(
-                operation:   'POST',
-                subpath:     "packages/#{package['id']}/transfer_spec/upload",
-                headers:     {'Accept' => 'application/json'},
-                url_params:  {transfer_type: TRANSFER_CONNECT},
-                json_params: {paths: transfer.ts_source_paths.map{|i|i['source']}}
-              )[:data]
-              transfer_spec.delete('authentication')
-              return Main.result_transfer(transfer.start(transfer_spec))
+              shared_folder = options.get_option(:shared_folder)
+              if shared_folder.nil?
+                # TODO: option to send from remote source or httpgw
+                transfer_spec = @api_v5.call(
+                  operation:   'POST',
+                  subpath:     "packages/#{package['id']}/transfer_spec/upload",
+                  headers:     {'Accept' => 'application/json'},
+                  url_params:  {transfer_type: TRANSFER_CONNECT},
+                  json_params: {paths: transfer.source_list}
+                )[:data]
+                transfer_spec.delete('authentication')
+                return Main.result_transfer(transfer.start(transfer_spec))
+              else
+                if !shared_folder.to_i.to_s.eql?(shared_folder)
+                  shared_folder = lookup_entity('shared_folders', 'name', shared_folder)['id']
+                end
+                transfer_request = {shared_folder_id: shared_folder, paths: transfer.source_list}
+                # start remote transfer and get first status
+                result = @api_v5.create("packages/#{package['id']}/remote_transfer", transfer_request)[:data]
+                result['id'] = package['id']
+                unless result['status'].eql?('completed')
+                  formatter.display_status("Package #{package['id']}")
+                  result = wait_for_complete_upload(package['id'])
+                end
+                return {type: :single_object, data: result}
+              end
             when :receive
               pkg_type = 'received'
               pack_id = instance_identifier
@@ -166,39 +253,67 @@ module Aspera
                 package_ids.reject!{|i|skip_ids_data.include?(i)}
               end
               result_transfer = []
-              package_ids.each do |pkgid|
+              package_ids.each do |pkg_id|
                 param_file_list = {}
                 begin
-                  param_file_list['paths'] = transfer.ts_source_paths.map{|i|i['source']}
+                  param_file_list['paths'] = transfer.source_list
                 rescue Aspera::Cli::CliBadArgument
                   # paths is optional
                 end
                 # TODO: allow from sent as well ?
                 transfer_spec = @api_v5.call(
                   operation:   'POST',
-                  subpath:     "packages/#{pkgid}/transfer_spec/download",
+                  subpath:     "packages/#{pkg_id}/transfer_spec/download",
                   headers:     {'Accept' => 'application/json'},
                   url_params:  {transfer_type: TRANSFER_CONNECT, type: pkg_type},
                   json_params: param_file_list
                 )[:data]
                 transfer_spec.delete('authentication')
                 statuses = transfer.start(transfer_spec)
-                result_transfer.push({'package' => pkgid, Main::STATUS_FIELD => statuses})
+                result_transfer.push({'package' => pkg_id, Main::STATUS_FIELD => statuses})
                 # skip only if all sessions completed
-                skip_ids_data.push(pkgid) if TransferAgent.session_status(statuses).eql?(:success)
+                skip_ids_data.push(pkg_id) if TransferAgent.session_status(statuses).eql?(:success)
               end
               skip_ids_persistency&.save
               return Main.result_transfer_multiple(result_transfer)
             end # case package
+          when :shared_folders
+            all_shared_folders = @api_v5.read('shared_folders')[:data]['shared_folders']
+            case options.get_next_command(%i[list browse])
+            when :list
+              return {type: :object_list, data: all_shared_folders}
+            when :browse
+              shared_folder_id = instance_identifier
+              path = options.get_next_argument('folder path', mandatory: false) || '/'
+              node = all_shared_folders.find{|i|i['id'].eql?(shared_folder_id)}
+              raise "No such shared folder id #{shared_folder_id}" if node.nil?
+              result = @api_v5.call({
+                operation:   'POST',
+                subpath:     "nodes/#{node['node_id']}/shared_folders/#{shared_folder_id}/browse",
+                headers:     {'Accept' => 'application/json', 'Content-Type' => 'application/json'},
+                json_params: {'path': path, 'filters': {'basenames': []}},
+                url_params:  {offset: 0, limit: 100}
+              })[:data]
+              if result.key?('items')
+                return {type: :object_list, data: result['items']}
+              else
+                return {type: :single_object, data: result['self']}
+              end
+            end
           when :admin
-            case options.get_next_command([:resource])
+            case options.get_next_command(%i[resource])
             when :resource
-              res_type = options.get_next_command(%i[accounts contacts jobs workgroups shared_inboxes nodes oauth_clients registrations saml_configs metadata_profiles])
+              res_type = options.get_next_command(%i[accounts contacts jobs workgroups shared_inboxes nodes oauth_clients registrations saml_configs metadata_profiles
+                                                     email_notifications])
               res_path = list_key = res_type.to_s
+              id_as_arg = false
               case res_type
               when :metadata_profiles
                 res_path = 'configuration/metadata_profiles'
                 list_key = 'profiles'
+              when :email_notifications
+                list_key = false
+                id_as_arg = 'type'
               end
               display_fields =
                 case res_type
@@ -207,10 +322,39 @@ module Aspera
                 end
               adm_api = @api_v5
               if res_type.eql?(:oauth_clients)
-                adm_api = Rest.new(@api_v5.params.merge({base_url: @faxpex5_api_auth_url}))
+                adm_api = Rest.new(@api_v5.params.merge({base_url: @faspex5_api_auth_url}))
               end
-              return entity_action(adm_api, res_path, item_list_key: list_key, display_fields: display_fields)
+              return entity_action(adm_api, res_path, item_list_key: list_key, display_fields: display_fields, id_as_arg: id_as_arg)
             end
+          when :gateway
+            require 'aspera/faspex_gw'
+            url = options.get_option(:value, is_type: :mandatory)
+            uri = URI.parse(url)
+            server = WebServerSimple.new(uri)
+            server.mount(uri.path, Faspex4GWServlet, @api_v5, nil)
+            trap('INT') { server.shutdown }
+            formatter.display_status("Faspex 4 gateway listening on #{url}")
+            Log.log.info("Listening on #{url}")
+            # this is blocking until server exits
+            server.start
+            return Main.result_status('Gateway terminated')
+          when :postprocessing
+            require 'aspera/faspex_postproc'
+            parameters = options.get_option(:value, is_type: :mandatory)
+            raise 'parameters must be Hash' unless parameters.is_a?(Hash)
+            parameters = parameters.symbolize_keys
+            raise 'Missing key: url' unless parameters.key?(:url)
+            uri = URI.parse(parameters[:url])
+            parameters[:processing] ||= {}
+            parameters[:processing][:root] = uri.path
+            server = WebServerSimple.new(uri, certificate: parameters[:certificate])
+            server.mount(uri.path, Faspex4PostProcServlet, parameters[:processing])
+            trap('INT') { server.shutdown }
+            formatter.display_status("Faspex 4 post processing listening on #{uri.port}")
+            Log.log.info("Listening on #{uri.port}")
+            # this is blocking until server exits
+            server.start
+            return Main.result_status('Gateway terminated')
           end # case command
         end # action
       end # Faspex5

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

@@ -40,12 +40,14 @@ module Aspera
           end
         end
 
+        # spellchecker: disable
         # SOAP API call to test central API
         CENTRAL_SOAP_API_TEST = '<?xml version="1.0" encoding="UTF-8"?>'\
           '<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:typ="urn:Aspera:XML:FASPSessionNET:2009/11:Types">'\
           '<soapenv:Header></soapenv:Header>'\
           '<soapenv:Body><typ:GetSessionInfoRequest><SessionFilter><SessionStatus>running</SessionStatus></SessionFilter></typ:GetSessionInfoRequest></soapenv:Body>'\
           '</soapenv:Envelope>'
+        # spellchecker: enable
 
         # fields removed in result of search
         SEARCH_REMOVE_FIELDS = %w[basename permissions].freeze
@@ -88,8 +90,8 @@ module Aspera
               Aspera::Node.new(params: {
                 base_url: options.get_option(:url, is_type: :mandatory),
                 headers:  {
-                  Aspera::Node::X_ASPERA_ACCESSKEY => options.get_option(:username, is_type: :mandatory),
-                  'Authorization'                  => options.get_option(:password, is_type: :mandatory)
+                  Aspera::Node::HEADER_X_ASPERA_ACCESS_KEY => options.get_option(:username, is_type: :mandatory),
+                  'Authorization'                          => options.get_option(:password, is_type: :mandatory)
                 }
               })
             else
@@ -141,10 +143,10 @@ module Aspera
         end
 
         # translates paths results into CLI result, and removes prefix
-        def c_result_translate_rem_prefix(resp, type, success_msg, path_prefix)
+        def c_result_translate_rem_prefix(response, type, success_msg, path_prefix)
           errors = []
           resres = { data: [], type: :object_list, fields: [type, 'result']}
-          JSON.parse(resp[:http].body)['paths'].each do |p|
+          JSON.parse(response[:http].body)['paths'].each do |p|
             result = success_msg
             if p.key?('error')
               Log.log.error{"#{p['error']['user_message']} : #{p['path']}"}
@@ -162,10 +164,10 @@ module Aspera
 
         # get path arguments from command line, and add prefix
         def get_next_arg_add_prefix(path_prefix, name, number=:single)
-          thepath = options.get_next_argument(name, expected: number)
-          return thepath if path_prefix.nil?
-          return File.join(path_prefix, thepath) if thepath.is_a?(String)
-          return thepath.map {|p| File.join(path_prefix, p)} if thepath.is_a?(Array)
+          path_or_list = options.get_next_argument(name, expected: number)
+          return path_or_list if path_prefix.nil?
+          return File.join(path_prefix, path_or_list) if path_or_list.is_a?(String)
+          return path_or_list.map {|p| File.join(path_prefix, p)} if path_or_list.is_a?(Array)
           raise StandardError, 'expect: nil, String or Array'
         end
 
@@ -185,8 +187,8 @@ module Aspera
             result = { type: :object_list, data: resp[:data]['items']}
             return Main.result_empty if result[:data].empty?
             result[:fields] = result[:data].first.keys.reject{|i|SEARCH_REMOVE_FIELDS.include?(i)}
-            self.format.display_status("Items: #{resp[:data]['item_count']}/#{resp[:data]['total_count']}")
-            self.format.display_status("params: #{resp[:data]['parameters'].keys.map{|k|"#{k}:#{resp[:data]['parameters'][k]}"}.join(',')}")
+            formatter.display_status("Items: #{resp[:data]['item_count']}/#{resp[:data]['total_count']}")
+            formatter.display_status("params: #{resp[:data]['parameters'].keys.map{|k|"#{k}:#{resp[:data]['parameters'][k]}"}.join(',')}")
             return c_result_remove_prefix_path(result, 'path', prefix_path)
           when :space
             path_list = get_next_arg_add_prefix(prefix_path, 'folder path or ext.val. list')
@@ -217,8 +219,7 @@ module Aspera
             resp = @api_node.create('files/rename', { 'paths' => [{ 'path' => path_base, 'source' => path_src, 'destination' => path_dst }] })
             return c_result_translate_rem_prefix(resp, 'entry', 'moved', prefix_path)
           when :browse
-            thepath = get_next_arg_add_prefix(prefix_path, 'path')
-            query = { path: thepath}
+            query = { path: get_next_arg_add_prefix(prefix_path, 'path')}
             additional_query = options.get_option(:query)
             query.merge!(additional_query) unless additional_query.nil?
             send_result = @api_node.create('files/browse', query)[:data]
@@ -227,7 +228,7 @@ module Aspera
             case send_result['self']['type']
             when 'directory', 'container' # directory: node, container: shares
               result = { data: send_result['items'], type: :object_list, textify: lambda { |table_data| c_textify_browse(table_data) } }
-              self.format.display_status("Items: #{send_result['item_count']}/#{send_result['total_count']}")
+              formatter.display_status("Items: #{send_result['item_count']}/#{send_result['total_count']}")
             else # 'file','symbolic_link'
               result = { data: send_result['self'], type: :single_object}
               # result={ data: [send_result['self']] , type: :object_list, textify: lambda { |table_data| c_textify_browse(table_data) } }
@@ -351,7 +352,7 @@ module Aspera
             case command_perm
             when :list
               # generic options : TODO: as arg ? option_url_query
-              list_options ||= {'include' => ['[]', 'access_level', 'permission_count']}
+              list_options ||= {'include' => [Rest::ARRAY_PARAMS, 'access_level', 'permission_count']}
               # add which one to get
               list_options['file_id'] = apifid[:file_id]
               list_options['inherited'] ||= false
@@ -392,8 +393,7 @@ module Aspera
             apifid = @api_node.resolve_api_fid(top_file_id, '')
             return Node.new(@agents.merge(skip_basic_auth_options: true, skip_node_options: true, node_api: apifid[:api])).execute_action(command_legacy)
           when :node_info, :bearer_token_node
-            thepath = options.get_next_argument('path')
-            apifid = @api_node.resolve_api_fid(top_file_id, thepath)
+            apifid = @api_node.resolve_api_fid(top_file_id, options.get_next_argument('path'))
             result = {
               url:     apifid[:api].params[:base_url],
               root_id: apifid[:file_id]
@@ -404,7 +404,7 @@ module Aspera
               result[:username] = apifid[:api].params[:auth][:username]
               result[:password] = apifid[:api].params[:auth][:password]
             when :oauth2
-              result[:username] = apifid[:api].params[:headers][Aspera::Node::X_ASPERA_ACCESSKEY]
+              result[:username] = apifid[:api].params[:headers][Aspera::Node::HEADER_X_ASPERA_ACCESS_KEY]
               result[:password] = apifid[:api].oauth_token
             else raise 'unknown'
             end
@@ -412,38 +412,34 @@ module Aspera
             raise 'not bearer token' unless result[:password].start_with?('Bearer ')
             return Main.result_status(result[:password])
           when :browse
-            thepath = options.get_next_argument('path')
-            apifid = @api_node.resolve_api_fid(top_file_id, thepath)
+            apifid = @api_node.resolve_api_fid(top_file_id, options.get_next_argument('path'))
             file_info = apifid[:api].read("files/#{apifid[:file_id]}")[:data]
             if file_info['type'].eql?('folder')
               result = apifid[:api].read("files/#{apifid[:file_id]}/files", options.get_option(:value))
               items = result[:data]
-              self.format.display_status("Items: #{result[:data].length}/#{result[:http]['X-Total-Count']}")
+              formatter.display_status("Items: #{result[:data].length}/#{result[:http]['X-Total-Count']}")
             else
               items = [file_info]
             end
             return {type: :object_list, data: items, fields: %w[name type recursive_size size modified_time access_level]}
           when :find
-            thepath = options.get_next_argument('path')
-            apifid = @api_node.resolve_api_fid(top_file_id, thepath)
+            apifid = @api_node.resolve_api_fid(top_file_id, options.get_next_argument('path'))
             test_block = Aspera::Node.file_matcher(options.get_option(:value))
             return {type: :object_list, data: @api_node.find_files(apifid[:file_id], test_block), fields: ['path']}
           when :mkdir
-            thepath = options.get_next_argument('path')
-            containing_folder_path = thepath.split(Aspera::Node::PATH_SEPARATOR)
+            containing_folder_path = options.get_next_argument('path').split(Aspera::Node::PATH_SEPARATOR)
             new_folder = containing_folder_path.pop
             apifid = @api_node.resolve_api_fid(top_file_id, containing_folder_path.join(Aspera::Node::PATH_SEPARATOR))
             result = apifid[:api].create("files/#{apifid[:file_id]}/files", {name: new_folder, type: :folder})[:data]
             return Main.result_status("created: #{result['name']} (id=#{result['id']})")
           when :rename
-            thepath = options.get_next_argument('source path')
+            file_path = options.get_next_argument('source path')
             newname = options.get_next_argument('new name')
-            apifid = @api_node.resolve_api_fid(top_file_id, thepath)
+            apifid = @api_node.resolve_api_fid(top_file_id, file_path)
             result = apifid[:api].update("files/#{apifid[:file_id]}", {name: newname})[:data]
-            return Main.result_status("renamed #{thepath} to #{newname}")
+            return Main.result_status("renamed #{file_path} to #{newname}")
           when :delete
-            thepath = options.get_next_argument('path')
-            return do_bulk_operation(thepath, 'deleted', id_result: 'path') do |l_path|
+            return do_bulk_operation(options.get_next_argument('path'), 'deleted', id_result: 'path') do |l_path|
               raise "expecting String (path), got #{l_path.class.name} (#{l_path})" unless l_path.is_a?(String)
               apifid = @api_node.resolve_api_fid(top_file_id, l_path)
               result = apifid[:api].delete("files/#{apifid[:file_id]}")[:data]
@@ -517,7 +513,7 @@ module Aspera
             asyncname = options.get_option(:sync_name)
             if asyncname.nil?
               asyncid = instance_identifier
-              if asyncid.eql?('ALL') && %i[show delete].include?(command)
+              if asyncid.eql?(VAL_ALL) && %i[show delete].include?(command)
                 asyncids = @api_node.read('async/list')[:data]['sync_ids']
               else
                 Integer(asyncid) # must be integer
@@ -540,7 +536,7 @@ module Aspera
           when :show
             resp = @api_node.create('async/summary', pdata)[:data]['sync_summaries']
             return Main.result_empty if resp.empty?
-            return { type: :object_list, data: resp, fields: %w[snid name local_dir remote_dir] } if asyncid.eql?('ALL')
+            return { type: :object_list, data: resp, fields: %w[snid name local_dir remote_dir] } if asyncid.eql?(VAL_ALL)
             return { type: :single_object, data: resp.first }
           when :delete
             resp = @api_node.create('async/delete', pdata)[:data]
@@ -628,16 +624,13 @@ module Aspera
               resp = @api_node.create('streams', options.get_option(:value, is_type: :mandatory))
               return { type: :single_object, data: resp[:data] }
             when :show
-              trid = options.get_next_argument('transfer id')
-              resp = @api_node.read('ops/transfers/' + trid)
+              resp = @api_node.read("ops/transfers/#{options.get_next_argument('transfer id')}")
               return { type: :other_struct, data: resp[:data] }
             when :modify
-              trid = options.get_next_argument('transfer id')
-              resp = @api_node.update('streams/' + trid, options.get_option(:value, is_type: :mandatory))
+              resp = @api_node.update("streams/#{options.get_next_argument('transfer id')}", options.get_option(:value, is_type: :mandatory))
               return { type: :other_struct, data: resp[:data] }
             when :cancel
-              trid = options.get_next_argument('transfer id')
-              resp = @api_node.cancel('streams/' + trid)
+              resp = @api_node.cancel("streams/#{options.get_next_argument('transfer id')}")
               return { type: :other_struct, data: resp[:data] }
             else
               raise 'error'

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

@@ -123,13 +123,16 @@ module Aspera
             case command
             when :status
               options = {}
-              options[:id] = wf_id unless wf_id.eql?('ALL')
+              options[:id] = wf_id unless wf_id.eql?(VAL_ALL)
               result = call_ao('workflows_status', options)[:data]
               return {type: :object_list, data: result['workflows']['workflow']}
             when :list
               result = call_ao('workflows_list', id: 0)[:data]
-              return {type: :object_list, data: result['workflows']['workflow'],
-fields: %w[id portable_id name published_status published_revision_id latest_revision_id last_modification]}
+              return {
+                type:   :object_list,
+                data:   result['workflows']['workflow'],
+                fields: %w[id portable_id name published_status published_revision_id latest_revision_id last_modification]
+              }
             when :details
               result = call_ao('workflow_details', id: wf_id)[:data]
               return {type: :object_list, data: result['workflows']['workflow']['statuses']}
@@ -160,7 +163,7 @@ fields: %w[id portable_id name published_status published_revision_id latest_rev
                 raise "Expects: work_step:result_name format, but got #{expected}" if fields.length != 2
                 call_params['explicit_output_step'] = fields[0]
                 call_params['explicit_output_variable'] = fields[1]
-                # implicitely, call is synchronous
+                # implicitly, call is synchronous
                 call_params['synchronous'] = true
               end
               if call_params['synchronous']