aspera-cli 4.19.0 → 4.21.1

data/lib/aspera/api/aoc.rb

@@ -12,18 +12,9 @@ require 'cgi'
 
 module Aspera
   module Api
-    SAAS_DOMAIN_PROD = 'ibmaspera.com'
-    class Alee < Aspera::Rest
-      def initialize(entitlement_id, customer_id, api_domain: SAAS_DOMAIN_PROD, version: 'v1')
-        super(
-          base_url: "https://api.#{api_domain}/metering/#{version}",
-          headers:  {'X-Aspera-Entitlement-Authorization' => Rest.basic_token(entitlement_id, customer_id)}
-        )
-      end
-    end
-
     class AoC < Aspera::Rest
       PRODUCT_NAME = 'Aspera on Cloud'
+      # use default workspace if it is set, else none
       DEFAULT_WORKSPACE = ''
       # Production domain of AoC
       SAAS_DOMAIN_PROD = 'ibmaspera.com' # cspell:disable-line
@@ -72,48 +63,61 @@ module Aspera
           return client_key, DataRepository.instance.item(client_key)
         end
 
-        # base API url depends on domain, which could be "qa.xxx"
-        def api_base_url(organization: 'api', api_domain: SAAS_DOMAIN_PROD)
-          return "https://#{organization}.#{api_domain}"
+        # base API url depends on domain, which could be "qa.xxx" or self-managed domain
+        def api_base_url(api_domain: SAAS_DOMAIN_PROD)
+          return "https://api.#{api_domain}"
         end
 
-        # split host of http://myorg.asperafiles.com in org and domain
-        def url_parts(uri)
+        # split host of URL into organization and domain
+        def split_org_domain(uri)
+          Aspera.assert_type(uri, URI)
           raise "No host found in URL.Please check URL format: https://myorg.#{SAAS_DOMAIN_PROD}" if uri.host.nil?
           parts = uri.host.split('.', 2)
           Aspera.assert(parts.length == 2){"expecting a public FQDN for #{PRODUCT_NAME}"}
-          return parts
+          parts[0] = nil if parts[0].eql?('api')
+          return %i{organization domain}.zip(parts).to_h
+        end
+
+        def saas_url?(url)
+          url.include?(SAAS_DOMAIN_PROD)
         end
 
         # @param url [String] URL of AoC public link
         # @return [Hash] information about public link, or nil if not a public link
         def link_info(url)
-          final_uri = Rest.new(base_url: url, redirect_max: MAX_AOC_URL_REDIRECT).read('')[:http].uri
-          raise 'AoC shall redirect to login page' if final_uri.query.nil?
-          decoded_query = Rest.decode_query(final_uri.query)
+          final_uri = Rest.new(base_url: url, redirect_max: MAX_AOC_URL_REDIRECT).call(operation: 'GET')[:http].uri
+          Log.log.trace1{Log.dump(:final_uri, final_uri)}
+          org_domain = split_org_domain(final_uri)
+          if (m = final_uri.path.match(%r{/oauth2/([^/]+)/login$}))
+            org_domain[:organization] = m[1] if org_domain[:organization].nil?
+          else
+            Log.log.debug{"path=#{final_uri.path} does not end with /login"}
+          end
+          raise 'AoC shall redirect to login page with a query' if final_uri.query.nil?
+          query = Rest.query_to_h(final_uri.query)
+          Log.log.trace1{Log.dump(:query, query)}
           # is that a public link ?
-          if decoded_query.key?('token')
+          if query.key?('token')
             Log.log.warn{"Unknown pub link path: #{final_uri.path}"} unless PUBLIC_LINK_PATHS.include?(final_uri.path)
             # ok we get it !
             return {
-              instance_domain: url_parts(final_uri)[1],
+              instance_domain: org_domain[:domain],
               url:             "https://#{final_uri.host}",
-              token:           decoded_query['token']
+              token:           query['token']
             }
           end
-          Log.log.debug{"path=#{final_uri.path} does not end with /login"} unless final_uri.path.end_with?('/login')
-          if decoded_query['state']
+          if query['state']
             # can be a private link
-            state_uri = URI.parse(decoded_query['state'])
-            if state_uri.query && decoded_query['redirect_uri']
-              decoded_state = Rest.decode_query(state_uri.query)
+            state_uri = URI.parse(query['state'])
+            if state_uri.query && query['redirect_uri']
+              decoded_state = Rest.query_to_h(state_uri.query)
               if decoded_state.key?('short_link_url')
                 if (m = state_uri.path.match(%r{/files/workspaces/([0-9]+)/all/([0-9]+):([0-9]+)}))
-                  redirect_uri = URI.parse(decoded_query['redirect_uri'])
-                  parts = url_parts(redirect_uri)
+                  redirect_uri = URI.parse(query['redirect_uri'])
+                  org_domain = split_org_domain(redirect_uri)
                   return {
-                    instance_domain: parts[1],
-                    organization:    parts[0],
+                    instance_domain: org_domain[:domain],
+                    organization:    org_domain[:organization],
                     url:             "https://#{redirect_uri.host}",
                     private_link:    {
                       workspace_id: m[1],
@@ -125,10 +129,10 @@ module Aspera
               end
             end
           end
-          parts = url_parts(URI.parse(url))
+          Log.log.debug{Log.dump(:org_domain, org_domain)}
           return {
-            instance_domain: parts[1],
-            organization:    parts[0]
+            instance_domain: org_domain[:domain],
+            organization:    org_domain[:organization]
           }
         end
       end
@@ -149,7 +153,8 @@ module Aspera
         @workspace_name = workspace
         @cache_user_info = nil
         @cache_url_token_info = nil
-        @context_cache = nil
+        @workspace_info = nil
+        @home_info = nil
         auth_params = {
           type:          :oauth2,
           client_id:     client_id,
@@ -187,6 +192,7 @@ module Aspera
           }
           # add jwt payload for global client id
           auth_params[:payload][:org] = url_info[:organization] if GLOBAL_CLIENT_APPS.include?(auth_params[:client_id])
+          auth_params[:cache_ids] = [url_info[:organization]]
         when :url_json
           auth_params[:url] = {grant_type: 'url_token'} # URL arguments
           auth_params[:json] = {url_token: url_info[:token]} # JSON body
@@ -206,7 +212,7 @@ module Aspera
         return nil unless auth_params[:grant_method].eql?(:url_json)
         return @cache_url_token_info unless @cache_url_token_info.nil?
         # TODO: can there be several in list ?
-        @cache_url_token_info = read('url_tokens')[:data].first
+        @cache_url_token_info = read('url_tokens').first
         return @cache_url_token_info
       end
 
@@ -225,7 +231,7 @@ module Aspera
         # get our user's default information
         @cache_user_info =
           begin
-            read('self')[:data]
+            read('self')
           rescue StandardError => e
             raise e if exception
             Log.log.debug{"ignoring error: #{e}"}
@@ -235,11 +241,20 @@ module Aspera
         return @cache_user_info
       end
 
-      # @param application [Symbol] :files or :packages
+      def workspace
+        raise 'internal error: AoC workspace context is not set' if @workspace_info.nil?
+        @workspace_info
+      end
+
+      def home
+        raise 'internal error: AoC home context is not set' if @home_info.nil?
+        @home_info
+      end
+
+      # Set the application context
+      # @param application [Symbol,NilClass] :files or :packages
       # @return [Hash] current context information: workspace, and home node/file if app is "Files"
-      def context(application = nil)
-        return @context_cache unless @context_cache.nil?
-        Aspera.assert(!application.nil?){'application must be set once'}
+      def context=(application)
         Aspera.assert_values(application, %i[files packages])
         ws_id =
           if !public_link.nil?
@@ -249,9 +264,10 @@ module Aspera
             Log.log.debug('Using workspace of private link')
             private_link[:workspace_id]
           elsif @workspace_name.eql?(DEFAULT_WORKSPACE)
-            Log.log.debug('Using default workspace'.green)
-            raise 'User does not have default workspace, please specify workspace' if current_user_info['default_workspace_id'].nil?
-            current_user_info['default_workspace_id']
+            if !current_user_info['default_workspace_id'].nil?
+              Log.log.debug('Using default workspace'.green)
+              current_user_info['default_workspace_id']
+            end
           elsif @workspace_name.nil?
             nil
           else
@@ -261,39 +277,49 @@ module Aspera
           if ws_id.nil?
             nil
           else
-            read("workspaces/#{ws_id}")[:data]
+            read("workspaces/#{ws_id}")
           end
-        @context_cache = if ws_info.nil?
-          {
-            workspace_id:   nil,
-            workspace_name: 'Shared folders'
-          }
-        else
-          {
-            workspace_id:   ws_info['id'],
-            workspace_name: ws_info['name']
-          }
-        end
-        return @context_cache unless application.eql?(:files)
-        if !public_link.nil?
-          assert_public_link_types(['view_shared_file'])
-          @context_cache[:home_node_id] = public_link['data']['node_id']
-          @context_cache[:home_file_id] = public_link['data']['file_id']
-        elsif !private_link.nil?
-          @context_cache[:home_node_id] = private_link[:node_id]
-          @context_cache[:home_file_id] = private_link[:file_id]
-        elsif ws_info
-          @context_cache[:home_node_id] = ws_info['home_node_id']
-          @context_cache[:home_file_id] = ws_info['home_file_id']
-        else
-          # not part of any workspace, but has some folder shared
-          user_info = current_user_info(exception: true) rescue {'read_only_home_node_id' => nil, 'read_only_home_file_id' => nil}
-          @context_cache[:home_node_id] = user_info['read_only_home_node_id']
-          @context_cache[:home_file_id] = user_info['read_only_home_file_id']
-        end
-        raise "Cannot get user's home node id, check your default workspace or specify one" if @context_cache[:home_node_id].to_s.empty?
-        Log.log.debug{Log.dump(:context, @context_cache)}
-        return @context_cache
+        @workspace_info =
+          if ws_info.nil?
+            {
+              id:   nil,
+              name: 'Shared folders'
+            }
+          else
+            {
+              id:   ws_info['id'],
+              name: ws_info['name']
+            }
+          end
+        Log.log.debug{Log.dump(:context, @workspace_info)}
+        return nil unless application.eql?(:files)
+        @home_info =
+          if !public_link.nil?
+            assert_public_link_types(['view_shared_file'])
+            {
+              node_id: public_link['data']['node_id'],
+              file_id: public_link['data']['file_id']
+            }
+          elsif !private_link.nil?
+            {
+              node_id: private_link[:node_id],
+              file_id: private_link[:file_id]
+            }
+          elsif ws_info
+            {
+              node_id: ws_info['home_node_id'],
+              file_id: ws_info['home_file_id']
+            }
+          else
+            # not part of any workspace, but has some folder shared
+            user_info = current_user_info(exception: true) rescue {'read_only_home_node_id' => nil, 'read_only_home_file_id' => nil}
+            {
+              node_id: user_info['read_only_home_node_id'],
+              file_id: user_info['read_only_home_file_id']
+            }
+          end
+        raise "Cannot get user's home node id, check your default workspace or specify one" if @home_info[:node_id].to_s.empty?
+        Log.log.debug{Log.dump(:context, @home_info)}
       end
 
       # @param node_id [String] identifier of node in AoC
@@ -304,9 +330,9 @@ module Aspera
       # @returns [Node] a node API for access key
       def node_api_from(node_id:, workspace_id: nil, workspace_name: nil, scope: Node::SCOPE_USER, package_info: nil)
         Aspera.assert_type(node_id, String)
-        node_info = read("nodes/#{node_id}")[:data]
+        node_info = read("nodes/#{node_id}")
         if workspace_name.nil? && !workspace_id.nil?
-          workspace_name = read("workspaces/#{workspace_id}")[:data]['name']
+          workspace_name = read("workspaces/#{workspace_id}")['name']
         end
         app_info = {
           api:            self, # for callback
@@ -346,7 +372,7 @@ module Aspera
           pkg_data['recipients'].first.is_a?(Hash) &&
           pkg_data['recipients'].first.key?('type') &&
           pkg_data['recipients'].first['type'].eql?('dropbox')
-        meta_schema = read("dropboxes/#{pkg_data['recipients'].first['id']}")[:data]['metadata_schema']
+        meta_schema = read("dropboxes/#{pkg_data['recipients'].first['id']}")['metadata_schema']
         if meta_schema.nil? || meta_schema.empty?
           Log.log.debug('no metadata in shared inbox')
           return
@@ -390,7 +416,7 @@ module Aspera
             # email: user, else dropbox
             entity_type = short_recipient_info.include?('@') ? 'contacts' : 'dropboxes'
             begin
-              full_recipient_info = lookup_by_name(entity_type, short_recipient_info, {'current_workspace_id' => ws_id})
+              full_recipient_info = lookup_by_name(entity_type, short_recipient_info, query: {'current_workspace_id' => ws_id})
             rescue RuntimeError => e
               raise e unless e.message.start_with?(ENTITY_NOT_FOUND)
               # dropboxes cannot be created on the fly
@@ -399,7 +425,7 @@ module Aspera
               full_recipient_info = create('contacts', {
                 'current_workspace_id' => ws_id,
                 'email'                => short_recipient_info
-              }.merge(new_user_option))[:data]
+              }.merge(new_user_option))
             end
             short_recipient_info = if entity_type.eql?('dropboxes')
               {'id' => full_recipient_info['id'], 'type' => 'dropbox'}
@@ -422,13 +448,12 @@ module Aspera
         case pkg_data['metadata']
         when Array, NilClass # no action
         when Hash
-          api_meta = []
-          pkg_data['metadata'].each do |k, v|
-            api_meta.push({
+          api_meta = pkg_data['metadata'].map do |k, v|
+            {
               # 'input_type' => 'single-dropdown',
               'name'   => k,
               'values' => v.is_a?(Array) ? v : [v]
-            })
+            }
           end
           pkg_data['metadata'] = api_meta
         else Aspera.error_unexpected_value(pkg_meta.class)
@@ -453,7 +478,7 @@ module Aspera
         validate_metadata(package_data) if validate_meta
 
         #  create a new package container
-        created_package = create('packages', package_data)[:data]
+        created_package = create('packages', package_data)
 
         package_node_api = node_api_from(
           node_id: created_package['node_id'],
@@ -463,7 +488,7 @@ module Aspera
         # tell AoC what to expect in package: 1 transfer (can also be done after transfer)
         # TODO: if multi session was used we should probably tell
         # also, currently no "multi-source" , i.e. only from client-side files, unless "node" agent is used
-        update("packages/#{created_package['id']}", {'sent' => true, 'transfers_expected' => 1})[:data]
+        update("packages/#{created_package['id']}", {'sent' => true, 'transfers_expected' => 1})
 
         return {
           spec: package_node_api.transfer_spec_gen4(created_package['contents_file_id'], Transfer::Spec::DIRECTION_SEND),
@@ -524,14 +549,14 @@ module Aspera
       ID_AK_ADMIN = 'ASPERA_ACCESS_KEY_ADMIN'
       # Callback from Plugins::Node
       # add application specific tags to permissions creation
-      # @param create_param [Hash] parameters for creating permissions
+      # @param perm_data [Hash] parameters for creating permissions
       # @param app_info [Hash] application information
-      def permissions_set_create_params(create_param:, app_info:)
+      def permissions_set_create_params(perm_data:, app_info:)
         # workspace shared folder:
         # access_id = "#{ID_AK_ADMIN}_WS_#{app_info[:workspace_id]}"
-        default_params = {
+        defaults = {
           # 'access_type'   => 'user', # mandatory: user or group
-          # 'access_id'     => access_id, # id of user or group
+          # 'access_id'     => access_id, # id of user or group or special
           'tags' => {
             Transfer::Spec::TAG_RESERVED => {
               'files' => {
@@ -543,6 +568,7 @@ module Aspera
                   'shared_by_name'    => current_user_info['name'],
                   'shared_by_email'   => current_user_info['email'],
                   # 'shared_with_name'  => access_id,
+                  # 'share_as'  => new_name_for_folder,
                   'access_key'        => app_info[:node_info]['access_key'],
                   'node'              => app_info[:node_info]['name']
                 }
@@ -550,34 +576,42 @@ module Aspera
             }
           }
         }
-        create_param.deep_merge!(default_params)
-        if create_param.key?('with')
-          contact_info = lookup_by_name(
-            'contacts',
-            create_param['with'],
-            {'current_workspace_id' => app_info[:workspace_id], 'context' => 'share_folder'})
-          create_param.delete('with')
-          create_param['access_type'] = contact_info['source_type']
-          create_param['access_id'] = contact_info['source_id']
-          create_param['tags'][Transfer::Spec::TAG_RESERVED]['files']['workspace']['shared_with_name'] = contact_info['email']
+        perm_data.deep_merge!(defaults)
+        tag_workspace = perm_data['tags'][Transfer::Spec::TAG_RESERVED]['files']['workspace']
+        case perm_data['with']
+        when NilClass
+        when ''
+          perm_data['access_type'] = 'user'
+          perm_data['access_id'] = "#{ID_AK_ADMIN}_WS_#{app_info[:workspace_id]}"
+          tag_workspace['shared_with_name'] = perm_data['access_id']
+        else
+          entity_info = lookup_by_name('contacts', perm_data['with'], query: {'current_workspace_id' => app_info[:workspace_id]})
+          perm_data['access_type'] = entity_info['source_type']
+          perm_data['access_id'] = entity_info['source_id']
+          tag_workspace['shared_with_name'] = entity_info['email']
+        end
+        perm_data.delete('with')
+        if perm_data.key?('as')
+          tag_workspace['share_as'] = perm_data['as']
+          perm_data.delete('as')
         end
         # optional
-        app_info[:opt_link_name] = create_param.delete('link_name')
+        app_info[:opt_link_name] = perm_data.delete('link_name')
       end
 
       # Callback from Plugins::Node
       # send shared folder event to AoC
-      # @param created_data [Hash] response from permission creation
+      # @param event_data [Hash] response from permission creation
       # @param app_info [Hash] hash with app info
       # @param types [Array] event types
-      def permissions_send_event(created_data:, app_info:, types: PERMISSIONS_CREATED)
+      def permissions_send_event(event_data:, app_info:, types: PERMISSIONS_CREATED)
         Aspera.assert_type(types, Array)
         Aspera.assert(!types.empty?)
         event_creation = {
           'types'        => types,
           'node_id'      => app_info[:node_info]['id'],
           'workspace_id' => app_info[:workspace_id],
-          'data'         => created_data
+          'data'         => event_data
         }
         # (optional). The name of the folder to be displayed to the destination user.
         # Use it if its value is different from the "share_as" field.

data/lib/aspera/api/ats.rb

@@ -34,7 +34,7 @@ module Aspera
         if @all_servers_cache.nil?
           @all_servers_cache = []
           CLOUD_NAME.each_key do |name|
-            read("servers/#{name.to_s.upcase}")[:data].each do |i|
+            read("servers/#{name.to_s.upcase}").each do |i|
               @all_servers_cache.push(i)
             end
           end

data/lib/aspera/api/cos_node.rb

@@ -19,7 +19,7 @@ module Aspera
             Aspera.assert(service_credentials.key?(field)){"service_credentials must have a field: #{field}"}
           end
           # read endpoints from service provided in service credentials
-          endpoints = Aspera::Rest.new(base_url: service_credentials['endpoints']).read('')[:data]
+          endpoints = Aspera::Rest.new(base_url: service_credentials['endpoints']).read('')
           Aspera::Log.dump('endpoints', endpoints)
           endpoint = endpoints.dig('service-endpoints', 'regional', bucket_region, 'public', bucket_region)
           raise "no such region: #{bucket_region}" if endpoint.nil?

data/lib/aspera/api/httpgw.rb

@@ -138,7 +138,7 @@ module Aspera
       def upload(transfer_spec)
         # identify this session uniquely
         session_id = SecureRandom.uuid
-        @notify_cb&.call(session_id: nil, type: :pre_start, info: 'starting')
+        @notify_cb&.call(:pre_start, session_id: nil, info: 'starting')
         # process files to send, modify `paths` in transfer_spec
         files_to_send = process_upload_list(transfer_spec)
         # total size of all files is last element
@@ -147,7 +147,7 @@ module Aspera
         Log.log.trace1{Log.dump(:files_to_send, files_to_send)}
         # TODO: check that this is available in endpoints: @api_info['endpoints']
         upload_url = File.join(@gw_root_url, @upload_version, 'upload')
-        @notify_cb&.call(session_id: nil, type: :pre_start, info: 'connecting wss')
+        @notify_cb&.call(:pre_start, session_id: nil, info: 'connecting wss')
         # open web socket to end point (equivalent to Net::HTTP.start)
         http_session = Rest.start_http_session(upload_url)
         # get the underlying socket i/o
@@ -172,11 +172,11 @@ module Aspera
         }
         # start read thread after handshake
         @ws_read_thread = Thread.new {process_read_thread}
-        @notify_cb&.call(session_id: session_id, type: :session_start)
-        @notify_cb&.call(session_id: session_id, type: :session_size, info: total_bytes_to_transfer)
+        @notify_cb&.call(:session_start, session_id: session_id)
+        @notify_cb&.call(:session_size, session_id: session_id, info: total_bytes_to_transfer)
         sleep(1)
         # notify progress bar
-        @notify_cb&.call(type: :session_size, session_id: session_id, info: total_bytes_to_transfer)
+        @notify_cb&.call(:session_size, session_id: session_id, info: total_bytes_to_transfer)
         # first step send transfer spec
         ws_snd_json(MSG_SEND_TRANSFER_SPEC, transfer_spec)
         # current file index
@@ -223,7 +223,7 @@ module Aspera
                 raise e
               end
               session_sent_bytes += slice_bin_data.length
-              @notify_cb&.call(type: :transfer, session_id: session_id, info: session_sent_bytes)
+              @notify_cb&.call(:transfer, session_id: session_id, info: session_sent_bytes)
               slice_info[:slice] += 1
             end
           ensure
@@ -232,8 +232,8 @@ module Aspera
           file_index += 1
         end
         # throttling may have skipped last one
-        @notify_cb&.call(type: :transfer, session_id: session_id, info: session_sent_bytes)
-        @notify_cb&.call(type: :end, session_id: session_id)
+        @notify_cb&.call(:transfer, session_id: session_id, info: session_sent_bytes)
+        @notify_cb&.call(:end, session_id: session_id)
         ws_send(ws_type: :close, data: nil)
         Log.log.debug("Finished upload, waiting for end of #{THR_RECV} thread.")
         @ws_read_thread.join
@@ -256,7 +256,7 @@ module Aspera
           end
           transfer_spec['download_name'] = download_name
         end
-        creation = create('download', {'transfer_spec' => transfer_spec})[:data]
+        creation = create('download', {'transfer_spec' => transfer_spec})
         transfer_uuid = creation['url'].split('/').last
         file_name =
           if transfer_spec['zip_required'] || transfer_spec['paths'].length > 1
@@ -274,6 +274,11 @@ module Aspera
         return @api_info
       end
 
+      # @return the base url of the gateway
+      def base_url
+        return @gw_root_url
+      end
+
       # @param url [String] URL of the HTTP Gateway, without version
       def initialize(
         url:,
@@ -299,7 +304,7 @@ module Aspera
         @synchronous = synchronous
         @notify_cb = notify_cb
         # get API info
-        @api_info = read('info')[:data].freeze
+        @api_info = read('info').freeze
         Log.log.debug{Log.dump(:api_info, @api_info)}
         # web socket endpoint: by default use v2 (newer gateways), without base64 encoding
         # is the latest supported? else revert to old api