aspera-cli 4.22.0 → 4.24.0

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

@@ -21,6 +21,7 @@ module Aspera
     module Plugins
       class Node < Cli::BasicAuthPlugin
         include SyncActions
+
         class << self
           # directory: node, container: shares
           FOLDER_TYPES = %w[directory container].freeze
@@ -58,10 +59,10 @@ module Aspera
               Log.log.debug{"detect error: #{e}"}
             end
             raise error if error
-            return nil
+            return
           end
 
-          def wizard(object:, private_key_path: nil, pub_key_pem: nil)
+          def wizard(object:, _private_key_path: nil, _pub_key_pem: nil)
             options = object.options
             return {
               preset_value: {
@@ -76,20 +77,24 @@ module Aspera
           def declare_options(options)
             return if @options_declared
             @options_declared = true
+            @dynamic_key = nil
             options.declare(:validator, 'Identifier of validator (optional for central)')
             options.declare(:asperabrowserurl, 'URL for simple aspera web ui', default: 'https://asperabrowser.mybluemix.net')
-            options.declare(:sync_name, 'Sync name')
             options.declare(
-              :default_ports, 'Use standard FASP ports or get from node api (gen4)', values: :bool, default: :yes,
-              handler: {o: Api::Node, m: :use_standard_ports})
+              :default_ports, 'Gen4: Use standard FASP ports (true) or get from node API (false)', values: :bool, default: :yes,
+              handler: {o: Api::Node, m: :use_standard_ports}
+            )
             options.declare(
-              :node_cache, 'Set to no to force actual file system read (gen4)', values: :bool,
-              handler: {o: Api::Node, m: :use_node_cache})
-            options.declare(:root_id, 'File id of top folder when using access key (override AK root id)')
+              :node_cache, 'Gen4: Set to no to force actual file system read', values: :bool,
+              handler: {o: Api::Node, m: :use_node_cache}
+            )
+            options.declare(:root_id, 'Gen4: File id of top folder when using access key (override AK root id)')
+            options.declare(:dynamic_key, 'Private key PEM to use for dynamic key auth', handler: {o: Api::Node, m: :use_dynamic_key})
             SyncActions.declare_options(options)
             options.parse_options!
           end
 
+          # Using /files/browse: is it a folder (node and shares)
           def gen3_entry_folder?(entry)
             FOLDER_TYPES.include?(entry['type'])
           end
@@ -104,10 +109,10 @@ module Aspera
           '</soapenv:Envelope>'
         # spellchecker: enable
 
-        # fields removed in result of search
+        # Fields removed in result of search
         SEARCH_REMOVE_FIELDS = %w[basename permissions].freeze
 
-        # actions in execute_command_gen3
+        # Actions in execute_command_gen3
         COMMANDS_GEN3 = %i[search space mkdir mklink mkfile rename delete browse upload download cat sync transport]
 
         BASE_ACTIONS = %i[api_details].concat(COMMANDS_GEN3).freeze
@@ -120,7 +125,7 @@ module Aspera
         # actions used commonly when a node is involved
         COMMON_ACTIONS = %i[access_keys].concat(BASE_ACTIONS).concat(SPECIAL_ACTIONS).freeze
 
-        private_constant(*%i[CENTRAL_SOAP_API_TEST SEARCH_REMOVE_FIELDS BASE_ACTIONS SPECIAL_ACTIONS V3_IN_V4_ACTIONS COMMON_ACTIONS])
+        private_constant :CENTRAL_SOAP_API_TEST, :SEARCH_REMOVE_FIELDS, :BASE_ACTIONS, :SPECIAL_ACTIONS, :V3_IN_V4_ACTIONS, :COMMON_ACTIONS
 
         # used in aoc
         NODE4_READ_ACTIONS = %i[bearer_token_node node_info browse find].freeze
@@ -137,16 +142,16 @@ module Aspera
 
         # @param api [Rest] an existing API object for the Node API
         # @param prefix_path [String,nil] for Faspex 4, allows browsing a package
-        def initialize(api: nil, prefix_path: nil, **env)
+        def initialize(context:, api: nil, prefix_path: nil)
           @prefix_path = prefix_path
-          super(**env, basic_options: api.nil?)
+          super(context: context, basic_options: api.nil?)
           Node.declare_options(options)
-          return if env[:broker].only_manual?
+          return if context.only_manual?
           @api_node =
             if !api.nil?
               # this can be Api::Node or Rest (Shares)
               api
-            elsif OAuth::Factory.bearer?(options.get_option(:password, mandatory: true))
+            elsif OAuth::Factory.bearer_auth?(options.get_option(:password, mandatory: true))
               # info is provided like node_info of aoc
               Api::Node.new(
                 base_url: options.get_option(:url, mandatory: true),
@@ -160,7 +165,8 @@ module Aspera
                   type:     :basic,
                   username: options.get_option(:username, mandatory: true),
                   password: options.get_option(:password, mandatory: true)
-                })
+                }
+              )
             end
         end
 
@@ -187,18 +193,17 @@ module Aspera
             result = success_msg
             if p.key?('error')
               Log.log.error{"#{p['error']['user_message']} : #{p['path']}"}
-              result = "ERROR: #{p['error']['user_message']}"
+              result = p['error']['user_message']
               errors.push([p['path'], p['error']['user_message']])
             end
             final_result[:data].push({type => p['path'], 'result' => result})
           end
           # one error make all fail
-          unless errors.empty?
-            raise errors.map{ |i| "#{i.first}: #{i.last}"}.join(', ')
-          end
+          raise errors.map{ |i| "#{i.first}: #{i.last}"}.join(', ') unless errors.empty?
           return c_result_remove_prefix_path(final_result, type)
         end
 
+        # Gen3 API
         def browse_gen3
           folders_to_process = [get_one_argument_with_prefix('path')]
           query = options.get_option(:query, default: {})
@@ -235,9 +240,7 @@ module Aspera
                 formatter.display_item_count(response['item_count'], total_count)
                 break
               end
-              if recursive
-                folders_to_process.concat(items.select{ |i| Node.gen3_entry_folder?(i)}.map{ |i| i['path']})
-              end
+              folders_to_process.concat(items.select{ |i| Node.gen3_entry_folder?(i)}.map{ |i| i['path']}) if recursive
               if !max_items.nil? && (all_items.count >= max_items)
                 all_items = all_items.slice(0, max_items) if all_items.count > max_items
                 break
@@ -349,7 +352,7 @@ module Aspera
               transfer_spec.delete_if{ |_k, v| v.nil?}
               # delete this part, as the returned value contains only destination, and not sources
               # transfer_spec.delete('paths') if command.eql?(:upload)
-              Log.log.debug{Log.dump(:ts, transfer_spec)}
+              Log.dump(:ts, transfer_spec)
               transfer_spec
             end
           when :upload, :download
@@ -363,10 +366,12 @@ module Aspera
             end
             # add fixed parameters if any (for COS)
             @api_node.add_tspec_info(request_transfer_spec) if @api_node.respond_to?(:add_tspec_info)
+            Api::Node.add_public_key(request_transfer_spec)
             # prepare payload for single request
             setup_payload = {transfer_requests: [{transfer_request: request_transfer_spec}]}
             # only one request, so only one answer
             transfer_spec = @api_node.create("files/#{command}_setup", setup_payload)['transfer_specs'].first['transfer_spec']
+            Api::Node.add_private_key(transfer_spec)
             # delete this part, as the returned value contains only destination, and not sources
             transfer_spec.delete('paths') if command.eql?(:upload)
             return Main.result_transfer(transfer.start(transfer_spec))
@@ -375,7 +380,8 @@ module Aspera
             File.basename(remote_path)
             result = @api_node.call(
               operation: 'GET',
-              subpath: "files/#{URI.encode_www_form_component(remote_path)}/contents")
+              subpath: "files/#{URI.encode_www_form_component(remote_path)}/contents"
+            )
             return Main.result_text(result[:http].body)
           when :transport
             return Main.result_single_object(@api_node.transport_params)
@@ -392,8 +398,12 @@ module Aspera
             ak_command = options.get_next_command(%i[do set_bearer_key].concat(Plugin::ALL_OPS))
             case ak_command
             when *Plugin::ALL_OPS
-              return entity_command(ak_command, @api_node, 'access_keys') do |field, value|
-                       raise Cli::BadIdentifier, 'only selector: %id:self' unless field.eql?('id') && value.eql?('self')
+              return entity_execute(
+                api: @api_node,
+                entity: 'access_keys',
+                command: ak_command
+              ) do |field, value|
+                       raise BadArgument, 'only selector: %id:self' unless field.eql?('id') && value.eql?('self')
                        @api_node.read('access_keys/self')['id']
                      end
             when :do
@@ -455,9 +465,7 @@ module Aspera
           when :license
             # requires: asnodeadmin -mu <node user> --acl-add=internal --internal
             node_license = @api_node.read('license')
-            if node_license['failure'].is_a?(String) && node_license['failure'].include?('ACL')
-              Log.log.error('server must have: asnodeadmin -mu <node user> --acl-add=internal --internal')
-            end
+            Log.log.error('server must have: asnodeadmin -mu <node user> --acl-add=internal --internal') if node_license['failure'].is_a?(String) && node_license['failure'].include?('ACL')
             return Main.result_single_object(node_license)
           when :api_details
             return Main.result_single_object({base_url: @api_node.base_url}.merge(@api_node.params))
@@ -468,7 +476,7 @@ module Aspera
         # @return [Hash] 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>') do |attribute, value|
-            raise Cli::BadIdentifier, 'Only selection "id" is supported (file id)' unless attribute.eql?('id')
+            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}
           end
@@ -486,7 +494,7 @@ 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(**init_params, api: apifid[:api]).execute_action(command_legacy)
+            return Node.new(context: context, api: apifid[:api]).execute_action(command_legacy)
           when :node_info, :bearer_token_node
             apifid = apifid_from_next_arg(top_file_id)
             result = {
@@ -505,8 +513,8 @@ module Aspera
             end
             return Main.result_single_object(result) if command_repo.eql?(:node_info)
             # check format of bearer token
-            OAuth::Factory.bearer_extract(result[:password])
-            return Main.result_status(result[:password])
+            OAuth::Factory.bearer_token(result[:password])
+            return Main.result_text(result[:password])
           when :browse
             apifid = apifid_from_next_arg(top_file_id)
             file_info = apifid[:api].read_with_cache("files/#{apifid[:file_id]}")
@@ -520,9 +528,8 @@ module Aspera
             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'])
           when :mkdir, :mklink, :mkfile
-            containing_folder_path = options.get_next_argument('path').split(Api::Node::PATH_SEPARATOR)
-            new_item = containing_folder_path.pop
-            apifid = @api_node.resolve_api_fid(top_file_id, containing_folder_path.join(Api::Node::PATH_SEPARATOR), true)
+            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)
             query = options.get_option(:query, mandatory: false)
             check_exists = true
             payload = {name: new_item}
@@ -576,61 +583,28 @@ module Aspera
           when :sync
             return execute_sync_action do |sync_direction, _local_path, remote_path|
               # Gen4 API
-              # direction is push pull, bidi
               Aspera.assert_values(sync_direction, %i[push pull bidi])
               ts_direction = case sync_direction
               when :push, :bidi then Transfer::Spec::DIRECTION_SEND
               when :pull then Transfer::Spec::DIRECTION_RECEIVE
               else Aspera.error_unreachable_line
               end
-              # remote is specified by option to_folder
+              # remote is specified by option: `to_folder`
               apifid = @api_node.resolve_api_fid(top_file_id, remote_path)
-              transfer_spec = apifid[:api].transfer_spec_gen4(apifid[:file_id], ts_direction)
-              Log.log.debug{Log.dump(:ts, transfer_spec)}
-              transfer_spec
+              apifid[: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)))
           when :download
-            source_paths = transfer.ts_source_paths
-            # special case for AoC : all files must be in same folder
-            source_folder = source_paths.shift['source']
-            # if a single file: split into folder and path
-            apifid = @api_node.resolve_api_fid(top_file_id, source_folder, true)
-            if source_paths.empty?
-              # get precise info in this element
-              file_info = apifid[:api].read("files/#{apifid[:file_id]}")
-              case file_info['type']
-              when 'file'
-                # if the single source is a file, we need to split into folder path and filename
-                src_dir_elements = source_folder.split(Api::Node::PATH_SEPARATOR)
-                # filename is the last one, source folder is what remains
-                source_paths = [{'source' => src_dir_elements.pop}]
-                apifid = @api_node.resolve_api_fid(top_file_id, src_dir_elements.join(Api::Node::PATH_SEPARATOR), true)
-              when 'link', 'folder'
-                # single source is 'folder' or 'link'
-                # TODO: add this ? , 'destination'=>file_info['name']
-                source_paths = [{'source' => '.'}]
-              else
-                raise BadArgument, "Unknown source type: #{file_info['type']}"
-              end
-            end
+            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})))
           when :cat
-            source_paths = transfer.ts_source_paths
-            source_folder = source_paths.shift['source']
-            if source_paths.empty?
-              source_folder = source_folder.split(Api::Node::PATH_SEPARATOR)
-              source_paths = [{'source' => source_folder.pop}]
-              source_folder = source_folder.join(Api::Node::PATH_SEPARATOR)
-            end
-            raise Cli::BadArgument, 'one file at a time only in HTTP mode' if source_paths.length > 1
-            file_name = source_paths.first['source']
-            apifid = @api_node.resolve_api_fid(top_file_id, File.join(source_folder, file_name))
+            apifid = apifid_from_next_arg(top_file_id)
             result = apifid[:api].call(
               operation: 'GET',
-              subpath: "files/#{apifid[:file_id]}/content")
+              subpath: "files/#{apifid[:file_id]}/content"
+            )
             return Main.result_text(result[:http].body)
           when :show
             apifid = apifid_from_next_arg(top_file_id)
@@ -648,7 +622,7 @@ module Aspera
               subpath: "files/#{apifid[:file_id]}/preview",
               headers: {'Accept' => 'image/png'}
             )
-            return Main.result_image(result[:http].body, formatter: formatter)
+            return Main.result_image(result[:http].body)
           when :permission
             apifid = apifid_from_next_arg(top_file_id)
             command_perm = options.get_next_command(%i[list show create delete])
@@ -665,7 +639,7 @@ module Aspera
               perm_id = instance_identifier
               return Main.result_single_object(apifid[:api].read("permissions/#{perm_id}"))
             when :delete
-              return do_bulk_operation(command: command_perm, descr: 'identifier', values: :identifier) do |one_id|
+              return do_bulk_operation(command: command_perm, values: :identifier) do |one_id|
                 apifid[:api].delete("permissions/#{one_id}")
                 # notify application of deletion
                 the_app = apifid[:api].app_info
@@ -692,25 +666,30 @@ module Aspera
           Aspera.error_unreachable_line
         end
 
-        # This is older API
+        # Search /async by name
+        # @param field [String] name of the field to search
+        # @param value [String] value of the field to search
+        # @return [Integer] id of the sync
+        # @raise [Cli::BadArgument] if no such sync, or not by name
+        def async_lookup(field, value)
+          raise Cli::BadArgument, "Only search by name is supported (#{field})" unless field.eql?('name')
+          async_ids = @api_node.read('async/list')['sync_ids']
+          summaries = @api_node.create('async/summary', {'syncs' => async_ids})['sync_summaries']
+          selected = summaries.find{ |s| s['name'].eql?(value)}
+          raise Cli::BadIdentifier.new('sync', "#{field}=#{value}") if selected.nil?
+          return selected['snid']
+        end
+
+        # Node API: /async (stats only)
         def execute_async
           command = options.get_next_command(%i[list delete files show counters bandwidth])
           unless command.eql?(:list)
-            async_name = options.get_option(:sync_name)
-            if async_name.nil?
-              async_id = instance_identifier
-              if async_id.eql?(SpecialValues::ALL) && %i[show delete].include?(command)
-                async_ids = @api_node.read('async/list')['sync_ids']
-              else
-                Integer(async_id) # must be integer
-                async_ids = [async_id]
-              end
-            else
+            async_id = 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']
-              summaries = @api_node.create('async/summary', {'syncs' => async_ids})['sync_summaries']
-              selected = summaries.find{ |s| s['name'].eql?(async_name)}
-              raise Cli::BadIdentifier, "no such sync: #{async_name}" if selected.nil?
-              async_id = selected['snid']
+            else
+              Integer(async_id) # must be integer
               async_ids = [async_id]
             end
             post_data = {'syncs' => async_ids}
@@ -718,7 +697,7 @@ module Aspera
           case command
           when :list
             resp = @api_node.read('async/list')['sync_ids']
-            return Main.result_value_list(resp, name: 'id')
+            return Main.result_value_list(resp)
           when :show
             resp = @api_node.create('async/summary', post_data)['sync_summaries']
             return Main.result_empty if resp.empty?
@@ -728,7 +707,7 @@ module Aspera
             resp = @api_node.create('async/delete', post_data)
             return Main.result_single_object(resp)
           when :bandwidth
-            post_data['seconds'] = 100 # TODO: as parameter with --value
+            post_data['seconds'] = 100 # TODO: as parameter with --query
             resp = @api_node.create('async/bandwidth', post_data)
             data = resp['bandwidth_data']
             return Main.result_empty if data.empty?
@@ -754,10 +733,10 @@ module Aspera
                   'sync_files',
                   options.get_option(:url, mandatory: true),
                   options.get_option(:username, mandatory: true),
-                  async_id]))
-              unless iteration_data.first.nil?
-                data.select!{ |l| l['fnid'].to_i > iteration_data.first}
-              end
+                  async_id
+                ])
+              )
+              data.select!{ |l| l['fnid'].to_i > iteration_data.first} unless iteration_data.first.nil?
               iteration_data[0] = data.last['fnid'].to_i unless data.empty?
             end
             return Main.result_empty if data.empty?
@@ -770,10 +749,11 @@ module Aspera
           end
         end
 
+        # Search /asyncs by name
+        # @param field [String] name of the field to search
+        # @param value [String] value of the field to search
         # @return [Integer] id of the sync
         # @raise [Cli::BadArgument] if no such sync, or not by name
-        # @param [String] field name of the field to search
-        # @param [String] value value of the field to search
         def ssync_lookup(field, value)
           raise Cli::BadArgument, "Only search by name is supported (#{field})" unless field.eql?('name')
           @api_node.read('asyncs')['ids'].each do |id|
@@ -781,7 +761,41 @@ module Aspera
             # name is unique, so we can return
             return id if sync_info[field].eql?(value)
           end
-          raise Cli::BadIdentifier, "no such sync: #{field}=#{value}"
+          raise Cli::BadIdentifier.new('ssync', "#{field}=#{value}")
+        end
+
+        WATCH_FOLDER_MUL = %i[create list].freeze
+        WATCH_FOLDER_SING = %i[show modify delete state].freeze
+        private_constant :WATCH_FOLDER_MUL, :WATCH_FOLDER_SING
+
+        def watch_folder_action
+          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_path = "#{res_class_path}/#{one_res_id}"
+          end
+          # hum, to avoid: Unable to convert 2016_09_14 configuration
+          @api_node.params[:headers] ||= {}
+          @api_node.params[:headers]['X-aspera-WF-version'] = '2017_10_23'
+          case command
+          when :create
+            resp = @api_node.create(res_class_path, value_create_modify(command: command))
+            return Main.result_status("#{resp['id']} created")
+          when :list
+            resp = @api_node.read(res_class_path, query_read_delete)
+            return Main.result_value_list(resp['ids'])
+          when :show
+            return Main.result_single_object(@api_node.read(one_res_path))
+          when :modify
+            @api_node.update(one_res_path, options.get_option(:query, mandatory: true))
+            return Main.result_status("#{one_res_id} updated")
+          when :delete
+            @api_node.delete(one_res_path)
+            return Main.result_status("#{one_res_id} deleted")
+          when :state
+            return Main.result_single_object(@api_node.read("#{one_res_path}/state"))
+          end
         end
 
         ACTIONS = %i[
@@ -799,16 +813,22 @@ module Aspera
           telemetry
         ].concat(COMMON_ACTIONS).freeze
 
-        def execute_action(command=nil)
+        def execute_action(command = nil)
           command ||= options.get_next_command(ACTIONS)
           case command
           when *COMMON_ACTIONS then return execute_simple_common(command)
           when :async then return execute_async # former API
           when :ssync
-            # newer API
-            sync_command = options.get_next_command(%i[start stop bandwidth counters files state summary].concat(Plugin::ALL_OPS) - %i[modify])
+            # Node API: /asyncs (newer)
+            sync_command = options.get_next_command(%i[start stop bandwidth counters files state summary] + Plugin::ALL_OPS - %i[modify])
             case sync_command
-            when *Plugin::ALL_OPS then return entity_command(sync_command, @api_node, 'asyncs', item_list_key: 'ids'){ |field, value| ssync_lookup(field, value)}
+            when *Plugin::ALL_OPS
+              return entity_execute(
+                api: @api_node,
+                entity: :asyncs,
+                command: sync_command,
+                items_key: 'ids'
+              ){ |field, value| ssync_lookup(field, value)}
             else
               asyncs_id = instance_identifier{ |field, value| ssync_lookup(field, value)}
               if %i[start stop].include?(sync_command)
@@ -849,7 +869,6 @@ module Aspera
             case command
             when :list
               transfer_filter = query_read_delete(default: {})
-              last_iteration_token = nil
               iteration_persistency = nil
               if options.get_option(:once_only, mandatory: true)
                 iteration_persistency = PersistencyActionOnce.new(
@@ -859,47 +878,19 @@ module Aspera
                     'node_transfers',
                     options.get_option(:url, mandatory: true),
                     options.get_option(:username, mandatory: true)
-                  ]))
+                  ])
+                )
                 if transfer_filter.delete('reset')
                   iteration_persistency.data.clear
                   iteration_persistency.save
                   return Main.result_status('Persistency reset')
                 end
-                last_iteration_token = iteration_persistency.data.first
               end
               raise Cli::BadArgument, 'reset only with once_only' if transfer_filter.key?('reset') && iteration_persistency.nil?
               max_items = transfer_filter.delete(MAX_ITEMS)
-              transfers_data = []
-              loop do
-                transfer_filter['iteration_token'] = last_iteration_token unless last_iteration_token.nil?
-                result = @api_node.call(operation: 'GET', subpath: 'ops/transfers', query: transfer_filter)
-                # no data
-                break if result[:data].empty?
-                # get next iteration token from link
-                next_iteration_token = nil
-                link_info = result[:http]['Link']
-                unless link_info.nil?
-                  m = link_info.match(/<([^>]+)>/)
-                  raise "Cannot parse iteration in Link: #{link_info}" if m.nil?
-                  next_iteration_token = CGI.parse(URI.parse(m[1]).query)['iteration_token']&.first
-                end
-                # same as last iteration: stop
-                break if next_iteration_token&.eql?(last_iteration_token)
-                last_iteration_token = next_iteration_token
-                transfers_data.concat(result[:data])
-                if max_items&.<=(transfers_data.length)
-                  transfers_data = transfers_data.slice(0, max_items)
-                  break
-                end
-                break if last_iteration_token.nil?
-              end
-              iteration_persistency&.data&.[]=(0, last_iteration_token)
+              transfers_data = call_with_iteration(api: @api_node, operation: 'GET', subpath: 'ops/transfers', max: max_items, query: transfer_filter, iteration: iteration_persistency&.data)
               iteration_persistency&.save
-              return {
-                type:   :object_list,
-                data:   transfers_data,
-                fields: %w[id status start_spec.direction start_spec.remote_user start_spec.remote_host start_spec.destination_path]
-              }
+              return Main.result_object_list(transfers_data, fields: %w[id status start_spec.direction start_spec.remote_user start_spec.remote_host start_spec.destination_path])
             when :sessions
               transfers_data = @api_node.read('ops/transfers', query_read_delete)
               sessions = transfers_data.map{ |t| t['sessions']}.flatten
@@ -907,11 +898,7 @@ module Aspera
                 session['start_time'] = Time.at(session['start_time_usec'] / 1_000_000.0).utc.iso8601(0)
                 session['end_time'] = Time.at(session['end_time_usec'] / 1_000_000.0).utc.iso8601(0)
               end
-              return {
-                type:   :object_list,
-                data:   sessions,
-                fields: %w[id status start_time end_time target_rate_kbps]
-              }
+              return Main.result_object_list(sessions, fields: %w[id status start_time end_time target_rate_kbps])
             when :cancel
               resp = @api_node.cancel("ops/transfers/#{instance_identifier}")
               return Main.result_single_object(resp)
@@ -970,9 +957,7 @@ module Aspera
             end
           when :service
             command = options.get_next_command(%i[list create delete])
-            if [:delete].include?(command)
-              service_id = instance_identifier
-            end
+            service_id = instance_identifier if [:delete].include?(command)
             case command
             when :list
               resp = @api_node.read('rund/services')
@@ -987,33 +972,7 @@ module Aspera
               return Main.result_status("#{service_id} deleted")
             end
           when :watch_folder
-            res_class_path = 'v3/watchfolders'
-            command = options.get_next_command(%i[create list show modify delete state])
-            if %i[show modify delete state].include?(command)
-              one_res_id = instance_identifier
-              one_res_path = "#{res_class_path}/#{one_res_id}"
-            end
-            # hum, to avoid: Unable to convert 2016_09_14 configuration
-            @api_node.params[:headers] ||= {}
-            @api_node.params[:headers]['X-aspera-WF-version'] = '2017_10_23'
-            case command
-            when :create
-              resp = @api_node.create(res_class_path, value_create_modify(command: command))
-              return Main.result_status("#{resp['id']} created")
-            when :list
-              resp = @api_node.read(res_class_path, query_read_delete)
-              return Main.result_value_list(resp['ids'], name: 'id')
-            when :show
-              return Main.result_single_object(@api_node.read(one_res_path))
-            when :modify
-              @api_node.update(one_res_path, options.get_option(:query, mandatory: true))
-              return Main.result_status("#{one_res_id} updated")
-            when :delete
-              @api_node.delete(one_res_path)
-              return Main.result_status("#{one_res_id} deleted")
-            when :state
-              return Main.result_single_object(@api_node.read("#{one_res_path}/state"))
-            end
+            return watch_folder_action
           when :central
             command = options.get_next_command(%i[session file])
             validator_id = options.get_option(:validator)
@@ -1027,11 +986,7 @@ module Aspera
                 request_data = options.get_next_argument('request data', mandatory: false, validation: Hash, default: {})
                 request_data.deep_merge!({'validation' => validation}) unless validation.nil?
                 resp = @api_node.create('services/rest/transfers/v1/sessions', request_data)
-                return {
-                  type:   :object_list,
-                  data:   resp['session_info_result']['session_info'],
-                  fields: %w[session_uuid status transport direction bytes_transferred]
-                }
+                return Main.result_object_list(resp['session_info_result']['session_info'], fields: %w[session_uuid status transport direction bytes_transferred])
               end
             when :file
               command = options.get_next_command(%i[list modify])
@@ -1041,7 +996,7 @@ module Aspera
                 request_data.deep_merge!({'validation' => validation}) unless validation.nil?
                 resp = @api_node.create('services/rest/transfers/v1/files', request_data)
                 resp = JSON.parse(resp) if resp.is_a?(String)
-                Log.log.debug{Log.dump(:resp, resp)}
+                Log.dump(:resp, resp)
                 return Main.result_object_list(resp['file_transfer_info_result']['file_transfer_info'], fields: %w[session_uuid file_id status path])
               when :modify
                 request_data = options.get_next_argument('request data', mandatory: false, validation: Hash, default: {})
@@ -1061,12 +1016,12 @@ module Aspera
             Environment.instance.open_uri("#{options.get_option(:asperabrowserurl)}?goto=#{encoded_params}")
             return Main.result_status('done')
           when :basic_token
-            return Main.result_status(Rest.basic_authorization(options.get_option(:username, mandatory: true), options.get_option(:password, mandatory: true)))
+            return Main.result_text(Rest.basic_authorization(options.get_option(:username, mandatory: true), options.get_option(:password, mandatory: true)))
           when :bearer_token
             private_key = OpenSSL::PKey::RSA.new(options.get_next_argument('private RSA key PEM value', validation: String))
             token_info = options.get_next_argument('user and group identification', validation: Hash)
             access_key = options.get_option(:username, mandatory: true)
-            return Main.result_status(Api::Node.bearer_token(payload: token_info, access_key: access_key, private_key: private_key))
+            return Main.result_text(Api::Node.bearer_token(payload: token_info, access_key: access_key, private_key: private_key))
           when :simulator
             require 'aspera/node_simulator'
             parameters = value_create_modify(command: command, default: {}).symbolize_keys
@@ -1077,7 +1032,7 @@ module Aspera
             return Main.result_status('Simulator terminated')
           when :telemetry
             parameters = value_create_modify(command: command, default: {}).symbolize_keys
-            %i[url apikey].each do |psym|
+            %i[url key].each do |psym|
               raise Cli::BadArgument, "Missing parameter: #{psym}" unless parameters.key?(psym)
             end
             require 'socket'
@@ -1085,79 +1040,69 @@ module Aspera
             parameters[:hostname] = Socket.gethostname unless parameters.key?(:hostname)
             interval = parameters[:interval].to_f
             raise Cli::BadArgument, 'Interval must be a positive number in seconds' if interval <= 0
-            backend_api = Rest.new(
+            otel_api = Rest.new(
               base_url: "#{parameters[:url]}/v1",
               headers: {
-                # 'Authorization'  => "apiToken #{parameters[:apikey]}",
-                'x-instana-key'  => parameters[:apikey],
+                # 'Authorization'  => "apiToken #{parameters[:key]}",
+                'x-instana-key'  => parameters[:key],
                 'x-instana-host' => parameters[:hostname]
               }
             )
-
-            loop do
-              start_time = Time.now
-              transfer_filter = {active_only: true}
-              transfers_data = []
-              loop do
-                result = @api_node.call(operation: 'GET', subpath: 'ops/transfers', query: transfer_filter)
-                # no data
-                break if result[:data].empty?
-                # get next iteration token from link
-                next_iteration_token = nil
-                link_info = result[:http]['Link']
-                unless link_info.nil?
-                  m = link_info.match(/<([^>]+)>/)
-                  Aspera.assert(m){"Cannot parse iteration in Link: #{link_info}"}
-                  next_iteration_token = CGI.parse(URI.parse(m[1]).query)['iteration_token']&.first
-                end
-                # same as last iteration: stop
-                break if next_iteration_token&.eql?(transfer_filter[:iteration_token])
-                transfer_filter[:iteration_token] = next_iteration_token
-                transfers_data.concat(result[:data])
-                break if next_iteration_token.nil?
-              end
-              puts("#{transfers_data.length} active transfers")
-              epoch_nsec = start_time.to_i * 1_000_000_000 + start_time.nsec
-              # https://www.ibm.com/docs/en/instana-observability/current?topic=instana-backend
-              backend_api.create('metrics', {
-                resourceMetrics: [
-                  {
-                    resource:     {
-                      attributes: [
+            datapoint = {
+              attributes:   [
+                {
+                  key:   'server.name',
+                  value: {
+                    stringValue: 'HSTS1'
+                  }
+                }
+              ],
+              asInt:        nil,
+              timeUnixNano: nil
+            }
+            # https://opentelemetry.io/docs/specs/otel/metrics/data-model/#gauge
+            metrics = {
+              resourceMetrics: [
+                {
+                  resource:     {
+                    attributes: [
+                      {
+                        key:   'service.name',
+                        value: {
+                          stringValue: 'IBMAspera'
+                        }
+                      }
+                    ]
+                  },
+                  scopeMetrics: [
+                    {
+                      metrics: [
                         {
-                          key:   'service.name',
-                          value: {
-                            stringValue: 'mycurl5'
+                          name:        'active.transfers',
+                          description: 'Number of active transfers',
+                          unit:        '1',
+                          gauge:       {
+                            dataPoints: [
+                              datapoint
+                            ]
                           }
                         }
                       ]
-                    },
-                    scopeMetrics: [
-                      {
-                        metrics: [
-                          {
-                            name:        'tutur2',
-                            unit:        '1',
-                            description: '',
-                            sum:         {
-                              aggregationTemporality: 1,
-                              isMonotonic:            true,
-                              dataPoints:             [
-                                {
-                                  asDouble:          4,
-                                  startTimeUnixNano: epoch_nsec,
-                                  timeUnixNano:      epoch_nsec
-                                }
-                              ]
-                            }
-                          }
-                        ]
-                      }
-                    ]
-                  }
-                ]
-              })
-              sleep([0, interval - (Time.now - start_time)].max)
+                    }
+                  ]
+                }
+              ]
+            }
+            loop do
+              timestamp = Time.now
+              transfers_data = call_with_iteration(api: @api_node, operation: 'GET', subpath: 'ops/transfers', query: {active_only: true})
+              datapoint[:asInt] = transfers_data.length
+              datapoint[:timeUnixNano] = timestamp.to_i * 1_000_000_000 + timestamp.nsec
+              Log.log.info("#{datapoint[:asInt]} active transfers")
+              # https://www.ibm.com/docs/en/instana-observability/current?topic=instana-backend
+              otel_api.create('metrics', metrics)
+              break if interval.eql?(0.0)
+              sleep([0.0, interval - (Time.now - timestamp)].max)
             end
           end
           Aspera.error_unreachable_line
@@ -1178,6 +1123,47 @@ module Aspera
           return path_arg if @prefix_path.nil?
           return File.join(@prefix_path, path_arg)
         end
+
+        # Executes the provided API call in loop
+        # @param api       [Rest]    the API to call
+        # @param iteration [Array]   a single element array with the iteration token or nil
+        # @param max       [Integer] maximum number of items to return, or nil for no limit
+        # @param query     [Hash]    query parameters to use for the API call
+        # @param call_args [Hash]    additional arguments to pass to the API call
+        # @return [Array] list of items returned by the API call
+        def call_with_iteration(api:, iteration: nil, max: nil, query: nil, **call_args)
+          Aspera.assert_type(iteration, Array, NilClass){'iteration'}
+          Aspera.assert_type(query, Hash, NilClass){'query'}
+          query_token = query&.dup || {}
+          item_list = []
+          query_token[:iteration_token] = iteration[0] unless iteration.nil?
+          loop do
+            result = api.call(**call_args, query: query_token)
+            Aspera.assert_type(result[:data], Array){"Expected data to be an Array, got: #{result[:data].class}"}
+            # no data
+            break if result[:data].empty?
+            # get next iteration token from link
+            next_iteration_token = nil
+            link_info = result[:http]['Link']
+            unless link_info.nil?
+              m = link_info.match(/<([^>]+)>/)
+              Aspera.assert(m){"Cannot parse iteration in Link: #{link_info}"}
+              next_iteration_token = CGI.parse(URI.parse(m[1]).query)['iteration_token']&.first
+            end
+            # same as last iteration: stop
+            break if next_iteration_token&.eql?(query_token[:iteration_token])
+            query_token[:iteration_token] = next_iteration_token
+            item_list.concat(result[:data])
+            if max&.<=(item_list.length)
+              item_list = item_list.slice(0, max)
+              break
+            end
+            break if next_iteration_token.nil?
+          end
+          # save iteration token if needed
+          iteration[0] = query_token[:iteration_token] unless iteration.nil?
+          item_list
+        end
       end
     end
   end