aspera-cli 4.11.0 → 4.12.0

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

@@ -51,6 +51,7 @@ module Aspera
           client_access_key
           kms_profile].freeze
         ENTITY_NAME_SPECIFIER = 'name'
+        PACKAGE_QUERY_DEFAULT = {'archived' => false, 'exclude_dropbox_packages' => true, 'has_content' => true, 'received' => true}.freeze
 
         def initialize(env)
           super(env)
@@ -59,8 +60,8 @@ module Aspera
           @cache_api_aoc = nil
           options.add_opt_list(:auth, Oauth::STD_AUTH_TYPES, 'OAuth type of authentication')
           options.add_opt_list(:operation, %i[push pull], 'client operation for transfers')
-          options.add_opt_simple(:client_id, 'OAuth API client identifier in application')
-          options.add_opt_simple(:client_secret, 'OAuth API client passcode')
+          options.add_opt_simple(:client_id, 'OAuth API client identifier')
+          options.add_opt_simple(:client_secret, 'OAuth API client secret')
           options.add_opt_simple(:redirect_uri, 'OAuth API client redirect URI')
           options.add_opt_simple(:private_key, 'OAuth JWT RSA private key PEM value (prefix file path with @file:)')
           options.add_opt_simple(:scope, 'OAuth scope for AoC API calls')
@@ -101,7 +102,7 @@ module Aspera
         def current_workspace_info
           return @cache_workspace_info unless @cache_workspace_info.nil?
           default_workspace_id = if aoc_api.url_token_data.nil?
-            aoc_api.user_info['default_workspace_id']
+            aoc_api.current_user_info['default_workspace_id']
           else
             aoc_api.url_token_data['data']['workspace_id']
           end
@@ -127,7 +128,7 @@ module Aspera
           Log.dump(:current_workspace_info, @cache_workspace_info)
           # display workspace
           default_flag = @cache_workspace_info['id'] == default_workspace_id ? ' (default)' : ''
-          self.format.display_status("Current Workspace: #{@cache_workspace_info['name'].to_s.red}#{default_flag}")
+          formatter.display_status("Current Workspace: #{@cache_workspace_info['name'].to_s.red}#{default_flag}")
           return @cache_workspace_info
         end
 
@@ -169,24 +170,6 @@ module Aspera
           return "#{resource_class_path}/#{get_resource_id_from_args(resource_class_path)}"
         end
 
-        def normalize_metadata(pkg_data)
-          case pkg_data['metadata']
-          when Array, NilClass # no action
-          when Hash
-            api_meta = []
-            pkg_data['metadata'].each do |k, v|
-              api_meta.push({
-                # 'input_type' => 'single-dropdown',
-                'name'   => k,
-                'values' => v.is_a?(Array) ? v : [v]
-              })
-            end
-            pkg_data['metadata'] = api_meta
-          else raise "metadata field if not of expected type: #{pkg_meta.class}"
-          end
-          return nil
-        end
-
         def assert_public_link_types(expected)
           raise CliBadArgument, "public link type is #{aoc_api.url_token_data['purpose']} but action requires one of #{expected.join(',')}" \
           unless expected.include?(aoc_api.url_token_data['purpose'])
@@ -194,7 +177,7 @@ module Aspera
 
         # Call aoc_api.read with same parameters.
         # Use paging if necessary to get all results
-        # @return {list: , total: }
+        # @return [Hash] {list: , total: }
         def read_with_paging(resource_class_path, base_query)
           raise 'Query must be Hash' unless base_query.is_a?(Hash)
           # set default large page if user does not specify own parameters. AoC Caps to 1000 anyway
@@ -231,11 +214,7 @@ module Aspera
         # @param file_id [String] root file id for the operation (can be AK root, or other, e.g. package, or link)
         # @param scope [String] node scope, or nil (admin)
         def execute_nodegen4_command(command_repo, node_id, file_id: nil, scope: nil)
-          top_node_api = aoc_api.node_id_to_api(
-            node_id: node_id,
-            plugin: self,
-            scope: scope
-          )
+          top_node_api = aoc_api.node_api_from(node_id: node_id, workspace_info: current_workspace_info, scope: scope)
           file_id = top_node_api.read("access_keys/#{top_node_api.app_info[:node_info]['access_key']}")[:data]['root_file_id'] if file_id.nil?
           node_plugin = Node.new(@agents.merge(
             skip_basic_auth_options: true,
@@ -251,12 +230,12 @@ module Aspera
             # default is push
             case options.get_option(:operation, is_type: :mandatory)
             when :push
-              client_tr_oper = Fasp::TransferSpec::DIRECTION_SEND
+              client_direction = Fasp::TransferSpec::DIRECTION_SEND
               client_folder = options.get_option(:from_folder, is_type: :mandatory)
-              server_folder = transfer.destination_folder(client_tr_oper)
+              server_folder = transfer.destination_folder(client_direction)
             when :pull
-              client_tr_oper = Fasp::TransferSpec::DIRECTION_RECEIVE
-              client_folder = transfer.destination_folder(client_tr_oper)
+              client_direction = Fasp::TransferSpec::DIRECTION_RECEIVE
+              client_folder = transfer.destination_folder(client_direction)
               server_folder = options.get_option(:from_folder, is_type: :mandatory)
             end
             client_apfid = top_node_api.resolve_api_fid(file_id, client_folder)
@@ -276,7 +255,7 @@ module Aspera
             }
             return Main.result_transfer(transfer.start(server_apfid[:api].transfer_spec_gen4(
               server_apfid[:file_id],
-              client_tr_oper,
+              client_direction,
               add_ts)))
           else raise "INTERNAL ERROR: Missing case: #{command_repo}"
           end # command_repo
@@ -285,7 +264,7 @@ module Aspera
 
         def execute_admin_action
           # upgrade scope to admin
-          aoc_api.oauth.gparams[:scope] = AoC::SCOPE_FILES_ADMIN
+          aoc_api.oauth.generic_parameters[:scope] = AoC::SCOPE_FILES_ADMIN
           command_admin = options.get_next_command(%i[ats resource usage_reports analytics subscription auth_providers])
           case command_admin
           when :auth_providers
@@ -365,16 +344,16 @@ module Aspera
             case command_analytics
             when :application_events
               event_type = command_analytics.to_s
-              events = analytics_api.read("organizations/#{aoc_api.user_info['organization_id']}/#{event_type}")[:data][event_type]
+              events = analytics_api.read("organizations/#{aoc_api.current_user_info['organization_id']}/#{event_type}")[:data][event_type]
               return {type: :object_list, data: events}
             when :transfers
               event_type = command_analytics.to_s
               filter_resource = options.get_option(:name) || 'organizations'
               filter_id = options.get_option(:id) ||
                 case filter_resource
-                when 'organizations' then aoc_api.user_info['organization_id']
-                when 'users' then aoc_api.user_info['id']
-                when 'nodes' then aoc_api.user_info['id'] # TODO: consistent ? # rubocop:disable Lint/DuplicateBranch
+                when 'organizations' then aoc_api.current_user_info['organization_id']
+                when 'users' then aoc_api.current_user_info['id']
+                when 'nodes' then aoc_api.current_user_info['id'] # TODO: consistent ? # rubocop:disable Lint/DuplicateBranch
                 else raise 'organizations or users for option --name'
                 end
               filter = options.get_option(:query) || {}
@@ -382,22 +361,22 @@ module Aspera
               filter['limit'] ||= 100
               if options.get_option(:once_only, is_type: :mandatory)
                 saved_date = []
-                startdate_persistency = PersistencyActionOnce.new(
+                start_date_persistency = PersistencyActionOnce.new(
                   manager: @agents[:persistency],
                   data: saved_date,
                   ids: IdGenerator.from_list(['aoc_ana_date', options.get_option(:url, is_type: :mandatory), current_workspace_info['name']].push(
                     filter_resource,
                     filter_id)))
-                start_datetime = saved_date.first
-                stop_datetime = Time.now.utc.strftime('%FT%T.%LZ')
-                # Log.log().error("start: #{start_datetime}")
-                # Log.log().error("end:   #{stop_datetime}")
-                saved_date[0] = stop_datetime
-                filter['start_time'] = start_datetime unless start_datetime.nil?
-                filter['stop_time'] = stop_datetime
+                start_date_time = saved_date.first
+                stop_date_time = Time.now.utc.strftime('%FT%T.%LZ')
+                # Log.log().error("start: #{start_date_time}")
+                # Log.log().error("end:   #{stop_date_time}")
+                saved_date[0] = stop_date_time
+                filter['start_time'] = start_date_time unless start_date_time.nil?
+                filter['stop_time'] = stop_date_time
               end
               events = analytics_api.read("#{filter_resource}/#{filter_id}/#{event_type}", option_url_query(filter))[:data][event_type]
-              startdate_persistency&.save
+              start_date_persistency&.save
               if !options.get_option(:notif_to).nil?
                 events.each do |tr_event|
                   config.send_email_template(values: {ev: tr_event})
@@ -463,7 +442,7 @@ module Aspera
               items = read_with_paging(resource_class_path, option_url_query(default_query))
               count_msg = "Items: #{items[:list].length}/#{items[:total]}"
               count_msg = count_msg.bg_red unless items[:list].length.eql?(items[:total].to_i)
-              self.format.display_status(count_msg)
+              formatter.display_status(count_msg)
               return {type: :object_list, data: items[:list], fields: default_fields}
             when :show
               object = aoc_api.read(resource_instance_path)[:data]
@@ -527,9 +506,9 @@ module Aspera
             when :profile
               case options.get_next_command(%i[show modify])
               when :show
-                return { type: :single_object, data: aoc_api.user_info(exception: true) }
+                return { type: :single_object, data: aoc_api.current_user_info(exception: true) }
               when :modify
-                aoc_api.update("users/#{aoc_api.user_info(exception: true)['id']}", options.get_next_argument('modified parameters (hash)'))
+                aoc_api.update("users/#{aoc_api.current_user_info(exception: true)['id']}", options.get_next_argument('modified parameters (hash)'))
                 return Main.result_status('modified')
               end
             end
@@ -551,46 +530,24 @@ module Aspera
             when :send
               package_data = options.get_option(:value, is_type: :mandatory)
               raise CliBadArgument, 'value must be hash, refer to doc' unless package_data.is_a?(Hash)
+              new_user_option = options.get_option(:new_user_option)
+              option_validate = options.get_option(:validate_metadata)
+              # works for both normal usr auth and link auth
+              package_data['workspace_id'] ||= current_workspace_info['id']
 
               if !aoc_api.url_token_data.nil?
                 assert_public_link_types(%w[send_package_to_user send_package_to_dropbox])
                 box_type = aoc_api.url_token_data['purpose'].split('_').last
                 package_data['recipients'] = [{'id' => aoc_api.url_token_data['data']["#{box_type}_id"], 'type' => box_type}]
-                # TODO: probably this line is not needed
-                current_workspace_info['id'] = aoc_api.url_token_data['data']['workspace_id']
+                # enforce workspace id from link (should be already ok, but in case user wanted to override)
+                package_data['workspace_id'] = aoc_api.url_token_data['data']['workspace_id']
               end
 
-              package_data['workspace_id'] = current_workspace_info['id']
-
-              # list of files to include in package, optional
-              # package_data['file_names']=self.transfer.ts_source_paths.map{|i|File.basename(i['source'])}
-
-              # lookup users
-              new_user_option = options.get_option(:new_user_option)
-              aoc_api.resolve_package_recipients(package_data, current_workspace_info['id'], 'recipients', new_user_option)
-              aoc_api.resolve_package_recipients(package_data, current_workspace_info['id'], 'bcc_recipients', new_user_option)
-              normalize_metadata(package_data)
-              aoc_api.validate_metadata(package_data) if options.get_option(:validate_metadata)
-
-              #  create a new package container
-              package_info = aoc_api.create('packages', package_data)[:data]
-
-              # tell AoC what to expect in package: 1 transfer (can also be done after transfer)
-              # TODO: if multisession was used we should probably tell
-              # also, currently no "multi-source" , i.e. only from client-side files, unless "node" agent is used
-              aoc_api.update("packages/#{package_info['id']}", {'sent' => true, 'transfers_expected' => 1})[:data]
-              package_node_api = aoc_api.node_id_to_api(
-                node_id:      package_info['node_id'],
-                plugin:       self,
-                package_info: package_info,
-                scope:        AoC::SCOPE_NODE_USER
-              )
-              # raise error if necessary (but not return, package info is returned on success)
-              Main.result_transfer(transfer.start(package_node_api.transfer_spec_gen4(
-                package_info['contents_file_id'],
-                Fasp::TransferSpec::DIRECTION_SEND)))
-              # return all info on package
-              return { type: :single_object, data: package_info}
+              # transfer may raise an error
+              created_package = aoc_api.create_package_simple(package_data, option_validate, new_user_option)
+              Main.result_transfer(transfer.start(created_package[:spec], rest_token: created_package[:node]))
+              # return all info on package (especially package id)
+              return { type: :single_object, data: created_package[:info]}
             when :recv
               if !aoc_api.url_token_data.nil?
                 assert_public_link_types(['view_received_package'])
@@ -608,35 +565,36 @@ module Aspera
                                              current_workspace_info['id']].concat(aoc_api.additional_persistence_ids)))
               end
               if VAL_ALL.eql?(ids_to_download)
+                query = option_url_query(PACKAGE_QUERY_DEFAULT)
+                raise 'option query must be Hash' unless query.is_a?(Hash)
+                if query.key?('dropbox_name')
+                  # convenience: specify name instead of id
+                  raise 'not both dropbox_name and dropbox_id' if query.key?('dropbox_id')
+                  query['dropbox_id'] = aoc_api.lookup_entity_by_name('dropboxes', query['dropbox_name'])['id']
+                  query.delete('dropbox_name')
+                end
+                query['workspace_id'] ||= current_workspace_info['id'] unless current_workspace_info['id'].eql?(:undefined)
                 # get list of packages in inbox
-                package_info = aoc_api.read('packages', {
-                  'archived'                 => false,
-                  'exclude_dropbox_packages' => true,
-                  'has_content'              => true,
-                  'received'                 => true,
-                  'workspace_id'             => current_workspace_info['id']})[:data]
+                package_info = aoc_api.read('packages', query)[:data]
                 # remove from list the ones already downloaded
                 ids_to_download = package_info.map{|e|e['id']}
                 # array here
                 ids_to_download.reject!{|id|skip_ids_data.include?(id)}
-              end # ALL
+              end # VAL_ALL
               # list here
               ids_to_download = [ids_to_download] unless ids_to_download.is_a?(Array)
               result_transfer = []
-              self.format.display_status("found #{ids_to_download.length} package(s).")
+              formatter.display_status("found #{ids_to_download.length} package(s).")
               ids_to_download.each do |package_id|
                 package_info = aoc_api.read("packages/#{package_id}")[:data]
-                self.format.display_status("downloading package: #{package_info['name']}")
-                package_node_api = aoc_api.node_id_to_api(
-                  node_id:      package_info['node_id'],
-                  plugin:       self,
-                  package_info: package_info,
-                  scope:        AoC::SCOPE_NODE_USER
-                )
-                statuses = transfer.start(package_node_api.transfer_spec_gen4(
-                  package_info['contents_file_id'],
-                  Fasp::TransferSpec::DIRECTION_RECEIVE,
-                  {'paths'=> [{'source' => '.'}]}))
+                formatter.display_status("downloading package: #{package_info['name']}")
+                package_node_api = aoc_api.node_api_from(package_info: package_info, scope: AoC::SCOPE_NODE_USER)
+                statuses = transfer.start(
+                  package_node_api.transfer_spec_gen4(
+                    package_info['contents_file_id'],
+                    Fasp::TransferSpec::DIRECTION_RECEIVE,
+                    {'paths'=> [{'source' => '.'}]}),
+                  rest_token: package_node_api)
                 result_transfer.push({'package' => package_id, Main::STATUS_FIELD => statuses})
                 # update skip list only if all transfer sessions completed
                 if TransferAgent.session_status(statuses).eql?(:success)
@@ -651,14 +609,14 @@ module Aspera
               return { type: :single_object, data: package_info }
             when :list
               display_fields = %w[id name bytes_transferred]
-              query = option_url_query({'archived' => false, 'exclude_dropbox_packages' => true, 'has_content' => true, 'received' => true})
+              query = option_url_query(PACKAGE_QUERY_DEFAULT)
+              raise 'option query must be Hash' unless query.is_a?(Hash)
               if query.key?('dropbox_name')
                 # convenience: specify name instead of id
                 raise 'not both dropbox_name and dropbox_id' if query.key?('dropbox_id')
                 query['dropbox_id'] = aoc_api.lookup_entity_by_name('dropboxes', query['dropbox_name'])['id']
                 query.delete('dropbox_name')
               end
-              raise 'option must be Hash' unless query.is_a?(Hash)
               if current_workspace_info['id'].eql?(:undefined)
                 display_fields.push('workspace_id')
               else
@@ -695,11 +653,7 @@ module Aspera
               create_params = nil
               shared_apfid = nil
               if !folder_dest.nil?
-                home_node_api = aoc_api.node_id_to_api(
-                  node_id: home_info[:node_id],
-                  plugin: self,
-                  scope: AoC::SCOPE_NODE_USER
-                )
+                home_node_api = aoc_api.node_api_from(node_id: home_info[:node_id], workspace_info: current_workspace_info, scope: AoC::SCOPE_NODE_USER)
                 shared_apfid = home_node_api.resolve_api_fid(home_info[:file_id], folder_dest)
                 create_params = {
                   file_id:      shared_apfid[:file_id],
@@ -741,8 +695,8 @@ module Aspera
                     'workspace_id'     => current_workspace_info['id'],
                     'workspace_name'   => current_workspace_info['name'],
                     'folder_name'      => 'my folder',
-                    'created_by_name'  => aoc_api.user_info['name'],
-                    'created_by_email' => aoc_api.user_info['email'],
+                    'created_by_name'  => aoc_api.current_user_info['name'],
+                    'created_by_email' => aoc_api.current_user_info['email'],
                     'access_key'       => shared_apfid[:api].app_info[:node_info]['access_key'],
                     'node'             => shared_apfid[:api].app_info[:node_info]['host']
                   }
@@ -789,7 +743,16 @@ module Aspera
             return execute_admin_action
           when :gateway
             require 'aspera/faspex_gw'
-            return FaspexGW.new(aoc_api, current_workspace_info['id']).start_server
+            url = options.get_option(:value, is_type: :mandatory)
+            uri = URI.parse(url)
+            server = WebServerSimple.new(uri)
+            server.mount(uri.path, Faspex4GWServlet, aoc_api, current_workspace_info['id'])
+            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')
           else
             raise "internal error: #{command}"
           end # action

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

@@ -44,7 +44,7 @@ module Aspera
         def execute_action_access_key
           commands = %i[create list show modify delete node cluster entitlement]
           command = options.get_next_command(commands)
-          # those dont require access key id
+          # those do not require access key id
           access_key_id = instance_identifier unless %i[create list].include?(command)
           case command
           when :create
@@ -154,11 +154,11 @@ module Aspera
             base_url: AtsApi.base_url + '/v2',
             headers:  rest_add_headers,
             auth:     {
-              type:     :oauth2,
-              base_url: 'https://iam.bluemix.net/identity',
+              type:         :oauth2,
+              base_url:     'https://iam.bluemix.net/identity',
               # does not work:  base_url:    'https://iam.cloud.ibm.com/identity',
-              crtype:   :generic,
-              generic:  {
+              grant_method: :generic,
+              generic:      {
                 grant_type:    'urn:ibm:params:oauth:grant-type:apikey',
                 response_type: 'cloud_iam',
                 apikey:        options.get_option(:ibm_api_key, is_type: :mandatory)
@@ -176,7 +176,7 @@ module Aspera
             if instance.nil?
               # Take the first Aspera on Cloud transfer service instance ID if not provided by user
               instance = ats_api_v2_auth_ibm.read('instances')[:data]['data'].first
-              self.format.display_status("using first instance: #{instance}")
+              formatter.display_status("using first instance: #{instance}")
             end
             rest_add_header = {'X-ATS-Service-Instance-Id' => instance}
           end