aspera-cli 4.24.2 → 4.25.0.pre

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

@@ -33,7 +33,7 @@ module Aspera
               # Faspex is always HTTPS
               next unless base_url.start_with?('https://')
               api = Rest.new(base_url: base_url, redirect_max: 1)
-              response = api.call(operation: 'GET', subpath: Api::Faspex::PATH_API_DETECT)[:http]
+              response = api.read(Api::Faspex::PATH_API_DETECT, ret: :resp)
               next unless response.code.start_with?('2') && response.body.strip.empty?
               # end is at -1, and subtract 1 for "/"
               url_length = -2 - Api::Faspex::PATH_API_DETECT.length
@@ -93,7 +93,7 @@ module Aspera
           super
           options.declare(:box, "Package inbox, either shared inbox name or one of: #{Api::Faspex::API_LIST_MAILBOX_TYPES.join(', ')} or #{SpecialValues::ALL}", default: 'inbox')
           options.declare(:shared_folder, 'Send package with files from shared folder')
-          options.declare(:group_type, 'Type of shared box', values: %i[shared_inboxes workgroups], default: :shared_inboxes)
+          options.declare(:group_type, 'Type of shared box', allowed: %i[shared_inboxes workgroups], default: :shared_inboxes)
           options.parse_options!
         end
 
@@ -222,8 +222,7 @@ module Aspera
           else
             # a single id was provided, or a list of ids
             package_ids = [package_ids] unless package_ids.is_a?(Array)
-            Aspera.assert_type(package_ids, Array){'Expecting a single package id or a list of ids'}
-            Aspera.assert(package_ids.all?(String)){'Package id shall be String'}
+            Aspera.assert_array_all(package_ids, String){'Package id(s)'}
             # packages = package_ids.map{|pkg_id|@api_v5.read("packages/#{pkg_id}")}
             packages = package_ids.map{ |pkg_id| {'id'=>pkg_id}}
           end
@@ -256,7 +255,7 @@ module Aspera
               content_type: Rest::MIME_JSON,
               body:         param_file_list,
               headers:      {'Accept' => Rest::MIME_JSON}
-            )[:data]
+            )
             # delete flag for Connect Client
             transfer_spec.delete('authentication')
             statuses = transfer.start(transfer_spec)
@@ -294,28 +293,29 @@ module Aspera
           until folders_to_process.empty?
             path = folders_to_process.shift
             loop do
-              response = @api_v5.call(
+              data, http = @api_v5.call(
                 operation:    'POST',
                 subpath:      browse_endpoint,
                 query:        query,
                 content_type: Rest::MIME_JSON,
                 body:         {'path' => path, 'filters' => filters},
-                headers:      {'Accept' => Rest::MIME_JSON}
+                headers:      {'Accept' => Rest::MIME_JSON},
+                ret:          :both
               )
-              all_items.concat(response[:data]['items'])
+              all_items.concat(data['items'])
               if !max_items.nil? && (all_items.count >= max_items)
                 all_items = all_items.slice(0, max_items) if all_items.count > max_items
                 break
               end
-              folders_to_process.concat(response[:data]['items'].select{ |i| i['type'].eql?('directory')}.map{ |i| i['path']}) if recursive
+              folders_to_process.concat(data['items'].select{ |i| i['type'].eql?('directory')}.map{ |i| i['path']}) if recursive
               if use_paging
-                iteration_token = response[:http][Api::Faspex::HEADER_ITERATION_TOKEN]
+                iteration_token = http[Api::Faspex::HEADER_ITERATION_TOKEN]
                 break if iteration_token.nil? || iteration_token.empty?
                 query['iteration_token'] = iteration_token
               else
-                total_count = response[:data]['total_count'] if total_count.nil?
-                break if response[:data]['item_count'].eql?(0)
-                query['offset'] += response[:data]['item_count']
+                total_count = data['total_count'] if total_count.nil?
+                break if data['item_count'].eql?(0)
+                query['offset'] += data['item_count']
               end
               formatter.long_operation_running(all_items.count)
             end
@@ -349,8 +349,7 @@ module Aspera
           when :delete
             ids = package_id
             ids = [ids] unless ids.is_a?(Array)
-            Aspera.assert_type(ids, Array){'Package identifier'}
-            Aspera.assert(ids.all?(String)){"Package id(s) shall be String, but have: #{ids.map(&:class).uniq.join(', ')}"}
+            Aspera.assert_array_all(ids, String){'Package id(s)'}
             # API returns 204, empty on success
             @api_v5.call(
               operation:    'DELETE',
@@ -372,29 +371,32 @@ module Aspera
               }]
             end
             normalize_recipients(parameters)
+            # User specified content prot in tspec, but faspex requires in package creation
+            # `transfer_spec/upload` will set `content_protection`
+            if transfer.user_transfer_spec['content_protection'] && !parameters.key?('ear_enabled')
+              transfer.user_transfer_spec.delete('content_protection')
+              parameters['ear_enabled'] = true
+            end
             package = @api_v5.create('packages', parameters)
             shared_folder = options.get_option(:shared_folder)
             if shared_folder.nil?
               # send from local files
-              transfer_spec = @api_v5.call(
-                operation:    'POST',
-                subpath:      "packages/#{package['id']}/transfer_spec/upload",
-                query:        {transfer_type: Api::Faspex::TRANSFER_CONNECT},
-                content_type: Rest::MIME_JSON,
-                body:         {paths: transfer.source_list},
-                headers:      {'Accept' => Rest::MIME_JSON}
-              )[:data]
+              transfer_spec = @api_v5.create(
+                "packages/#{package['id']}/transfer_spec/upload",
+                {paths: transfer.source_list},
+                query: {transfer_type: Api::Faspex::TRANSFER_CONNECT}
+              )
               # well, we asked a TS for connect, but we actually want a generic one
               transfer_spec.delete('authentication')
               return Main.result_transfer(transfer.start(transfer_spec))
             else
               # send from remote shared folder
-              if (m = shared_folder.match(REGEX_LOOKUP_ID_BY_FIELD))
+              if (m = Base.percent_selector(shared_folder))
                 shared_folder = lookup_entity_by_field(
                   api: @api_v5,
                   entity: 'shared_folders',
-                  field: m[1],
-                  value: ExtendedValue.instance.evaluate(m[2])
+                  field: m[:field],
+                  value: m[:value]
                 )['id']
               end
               transfer_request = {shared_folder_id: shared_folder, paths: transfer.source_list}
@@ -512,20 +514,20 @@ module Aspera
               users = options.get_next_argument('user id, %name:, or Array')
               users = [users] unless users.is_a?(Array)
               users = users.map do |user|
-                if (m = user.match(REGEX_LOOKUP_ID_BY_FIELD))
+                if (m = Base.percent_selector(user))
                   lookup_entity_by_field(
                     api: @api_v5,
                     entity: 'accounts',
-                    field: m[1],
-                    value: ExtendedValue.instance.evaluate(m[2]),
-                    query: Rest.php_style({type: %w{local_user saml_user self_registered_user external_user}})
+                    field: m[:field],
+                    value: m[:value],
+                    query: Rest.php_style({type: ACCOUNT_TYPES})
                   )['id']
                 else
                   # it's the user id (not member id...)
                   user
                 end
               end
-              access = options.get_next_argument('level', mandatory: false, accept_list: %i[submit_only standard shared_inbox_admin], default: :standard)
+              access = options.get_next_argument('level', mandatory: false, accept_list: SHARED_INBOX_MEMBER_LEVELS, default: :standard)
               options.unshift_next_argument({user: users.map{ |u| {id: u, access: access}}})
             end
             return entity_execute(
@@ -536,10 +538,10 @@ module Aspera
             ) do |field, value|
                      lookup_entity_by_field(
                        api: @api_v5,
-                       entity: 'accounts',
+                       entity: 'contacts',
                        field: field,
                        value: value,
-                       query: Rest.php_style({type: %w{local_user saml_user self_registered_user external_user}})
+                       query: Rest.php_style({type: %w[user]})
                      )['id']
                    end
           when :reset_password
@@ -552,12 +554,8 @@ module Aspera
         end
 
         def execute_admin
-          command = options.get_next_command(%i[configuration smtp resource events clean_deleted].concat(Api::Faspex::ADMIN_RESOURCES).freeze)
+          command = options.get_next_command(%i[configuration smtp events clean_deleted].concat(Api::Faspex::ADMIN_RESOURCES).freeze)
           case command
-          when :resource
-            # resource will be deprecated
-            Log.log.warn('resource command is deprecated (4.18), directly use the specific command instead')
-            return execute_resource(options.get_next_command(Api::Faspex::ADMIN_RESOURCES))
           when *Api::Faspex::ADMIN_RESOURCES
             return execute_resource(command)
           when :clean_deleted
@@ -630,16 +628,16 @@ module Aspera
           when :health
             nagios = Nagios.new
             begin
-              http_res = Rest.new(base_url: options.get_option(:url, mandatory: true))
-                .call(operation: 'GET', subpath: 'health', headers: {'Accept' => Rest::MIME_JSON})
-              http_res[:data].each do |k, v|
+              data, http = Rest.new(base_url: options.get_option(:url, mandatory: true))
+                .read('health', ret: :both)
+              data.each do |k, v|
                 nagios.add_ok(k, v.to_s)
               end
-              nagios.add_ok('version', http_res[:http]['X-IBM-Aspera']) if http_res[:http]['X-IBM-Aspera']
+              nagios.add_ok('version', http['X-IBM-Aspera']) if http['X-IBM-Aspera']
             rescue StandardError => e
               nagios.add_critical('core', e.to_s)
             end
-            return nagios.result
+            Main.result_object_list(nagios.status_list)
           when :user
             case options.get_next_command(%i[account profile])
             when :account
@@ -718,6 +716,10 @@ module Aspera
             return Main.result_status('Gateway terminated')
           end
         end
+        SHARED_INBOX_MEMBER_LEVELS = %i[submit_only standard shared_inbox_admin].freeze
+        ACCOUNT_TYPES = %w{local_user saml_user self_registered_user external_user}.freeze
+        CONTACT_TYPES = %w{workgroup shared_inbox distribution_list user external_user}.freeze
+        private_constant :SHARED_INBOX_MEMBER_LEVELS, :ACCOUNT_TYPES, :CONTACT_TYPES
       end
     end
   end

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

@@ -15,9 +15,9 @@ module Aspera
 
           def detect(base_url)
             api = Rest.new(base_url: base_url)
-            ping_result = api.call(operation: 'GET', subpath: 'ping', headers: {'Accept' => Rest::MIME_JSON})
-            server_type = ping_result[:http]['Server']
-            return unless ping_result[:data].is_a?(Hash) && ping_result[:data].empty?
+            data, http = api.read('ping', ret: :both)
+            server_type = http['Server']
+            return unless data.is_a?(Hash) && data.empty?
             return unless server_type.is_a?(String) && server_type.include?('faspio')
             return {
               version: server_type.gsub(%r{^.*/}, ''),
@@ -42,7 +42,7 @@ module Aspera
 
         def initialize(**_)
           super
-          options.declare(:auth, 'OAuth type of authentication', values: %i[jwt basic])
+          options.declare(:auth, 'OAuth type of authentication', allowed: %i[jwt basic])
           options.declare(:client_id, 'OAuth client identifier')
           options.declare(:private_key, 'OAuth JWT RSA private key PEM value (prefix file path with @file:)')
           options.declare(:passphrase, 'OAuth JWT RSA private key passphrase')
@@ -88,7 +88,7 @@ module Aspera
             rescue StandardError => e
               nagios.add_critical('api', e.to_s)
             end
-            return nagios.result
+            Main.result_object_list(nagios.status_list)
           when :bridges
             return entity_execute(api: api, entity: 'bridges')
           end

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

@@ -56,7 +56,7 @@ module Aspera
             rescue StandardError => e
               nagios.add_critical('api', e.to_s)
             end
-            return nagios.result
+            Main.result_object_list(nagios.status_list)
           when :info
             api_v1 = Api::Httpgw.new(url: base_url)
             return Main.result_single_object(api_v1.info)