aspera-cli 4.24.2 → 4.25.0.pre2

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

@@ -17,13 +17,13 @@ module Aspera
             nagios = Nagios.new
             begin
               api = Api::Alee.new(nil, nil, version: 'ping')
-              result = api.call(operation: 'GET')
-              raise "unexpected response: #{result[:http].body}" unless result[:http].body.eql?('pong')
+              http = api.read(nil, ret: :resp)
+              raise "unexpected response: #{http.body}" unless http.body.eql?('pong')
               nagios.add_ok('api', 'answered ok')
             rescue StandardError => e
               nagios.add_critical('api', e.to_s)
             end
-            return nagios.result
+            Main.result_object_list(nagios.status_list)
           when :entitlement
             entitlement_id = options.get_option(:username, mandatory: true)
             customer_id = options.get_option(:password, mandatory: true)

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

@@ -62,6 +62,7 @@ module Aspera
             'Aspera on Cloud'
           end
 
+          # @return [Hash,NilClass]
           def detect(base_url)
             # no protocol ?
             base_url = "https://#{base_url}" unless base_url.match?(%r{^[a-z]{1,6}://})
@@ -69,9 +70,9 @@ module Aspera
             base_url = "#{base_url}.#{Api::AoC::SAAS_DOMAIN_PROD}" unless base_url.include?('.')
             # AoC is only https
             return unless base_url.start_with?('https://')
-            res_http = Rest.new(base_url: base_url, redirect_max: 0).call(operation: 'GET', subpath: 'auth/ping', exception: false)[:http]
-            return if res_http['Location'].nil?
-            redirect_uri = URI.parse(res_http['Location'])
+            location = Rest.new(base_url: base_url, redirect_max: 0).call(operation: 'GET', subpath: 'auth/ping', exception: false, ret: :resp)['Location']
+            return if location.nil?
+            redirect_uri = URI.parse(location)
             od = Api::AoC.split_org_domain(URI.parse(base_url))
             return unless redirect_uri.path.end_with?("oauth2/#{od[:organization]}/login")
             # either in standard domain, or product name in page
@@ -81,7 +82,8 @@ module Aspera
             }
           end
 
-          # @param base [String] Base folder path
+          # @param base   [String] Base folder path
+          # @param always [Bool]   `true` always add number, `false` only if base folder already exists
           # @return [String] Folder path that does jot exist, with possible .<number> extension
           def next_available_folder(base, always: false)
             counter = always ? 1 : 0
@@ -95,27 +97,26 @@ module Aspera
           # Get folder path that does not exist
           # If it exists, an extension is added
           # or a sequential number if extension == :seq
-          # @param folder [String] base folder
-          def unique_folder(folder, extension: nil, always: false)
-            case extension
-            when nil
-              folder
-            when :seq
-              # reuse helper
-              next_available_folder(folder, always: always)
-            else
-              if Dir.exist?(folder) || always
-                # NOTE: it might already exist
-                "#{folder}.#{Environment.instance.sanitized_filename(extension)}"
-              else
-                folder
-              end
+          # @param package_info       [Hash]   Package information
+          # @param destination_folder [String] Base folder
+          # @param fld.               [Array]  List of fields of package
+          def unique_folder(package_info, destination_folder, fld: nil, seq: false, opt: false)
+            Aspera.assert_array_all(fld, String, type: Cli::BadArgument){'fld'}
+            Aspera.assert([1, 2].include?(fld.length)){'fld must have 1 or 2 elements'}
+            folder = Environment.instance.sanitized_filename(package_info[fld[0]])
+            if seq
+              folder = next_available_folder(folder, always: !opt)
+            elsif fld[1] && (Dir.exist?(folder) || !opt)
+              # NOTE: it might already exist
+              folder = "#{folder}.#{Environment.instance.sanitized_filename(fld[1])}"
             end
+            puts("sub= #{folder}")
+            File.join(destination_folder, folder)
           end
         end
 
         # @param wizard  [Wizard] The wizard object
-        # @param app_url [Wizard] The wizard object
+        # @param app_url [String] Tested URL
         # @return [Hash] :preset_value, :test_args
         def wizard(wizard, app_url)
           pub_link_info = Api::AoC.link_info(app_url)
@@ -132,7 +133,7 @@ module Aspera
               test_args:    'organization'
             }
           end
-          options.declare(:use_generic_client, 'Wizard: AoC: use global or org specific jwt client id', values: :bool, default: Api::AoC.saas_url?(app_url))
+          options.declare(:use_generic_client, 'Wizard: AoC: use global or org specific jwt client id', allowed: Allowed::TYPES_BOOLEAN, default: Api::AoC.saas_url?(app_url))
           options.parse_options!
           # make username mandatory for jwt, this triggers interactive input
           wiz_username = options.get_option(:username, mandatory: true)
@@ -205,10 +206,10 @@ module Aspera
           @cache_workspace_info = nil
           @cache_home_node_file = nil
           @cache_api_aoc = nil
-          options.declare(:workspace, 'Name of workspace', types: [String, NilClass], default: Api::AoC::DEFAULT_WORKSPACE)
-          options.declare(:new_user_option, 'New user creation option for unknown package recipients', types: Hash)
-          options.declare(:validate_metadata, 'Validate shared inbox metadata', values: :bool, default: true)
-          options.declare(:package_folder, 'Field of package to use as folder name, or @none:', types: [String, NilClass])
+          options.declare(:workspace, 'Name of workspace', allowed: [String, NilClass], default: Api::AoC::DEFAULT_WORKSPACE)
+          options.declare(:new_user_option, 'New user creation option for unknown package recipients', allowed: Hash)
+          options.declare(:validate_metadata, 'Validate shared inbox metadata', allowed: Allowed::TYPES_BOOLEAN, default: true)
+          options.declare(:package_folder, 'Handling of reception of packages in folders', allowed: Hash, default: {})
           options.parse_options!
           # add node plugin options (for manual)
           Node.declare_options(options)
@@ -245,7 +246,7 @@ module Aspera
 
         # Generate or update Hash with workspace id and name (option), if not already set
         # @param hash   [Hash, Nil] set in provided hash
-        # @param string [Bool] true to set key as string, else as symbol
+        # @param string [TrueClass,FalseClass] true to set key as string, else as symbol
         # @param name   [Bool] include name
         # @return [Hash] with key `workspace_[id,name]` (symbol or string) only if defined
         def workspace_id_hash(hash: nil, string: false, name: false)
@@ -288,7 +289,7 @@ module Aspera
           query = query_read_delete(default: default_query)
           # caller may add specific modifications or checks to query
           yield(query) if block_given?
-          result = aoc_api.read_with_paging(resource_class_path, query: base_query.merge(query).compact, formatter: formatter)
+          result = aoc_api.read_with_paging(resource_class_path, base_query.merge(query).compact, formatter: formatter)
           return Main.result_object_list(result[:items], fields: fields, total: result[:total])
         end
 
@@ -313,7 +314,7 @@ module Aspera
           Aspera.assert_type(query, Hash){'query'}
           PACKAGE_RECEIVED_BASE_QUERY.each{ |k, v| query[k] = v unless query.key?(k)}
           resolve_dropbox_name_default_ws_id(query)
-          return aoc_api.read_with_paging('packages', query: query.compact, formatter: formatter)
+          return aoc_api.read_with_paging('packages', query.compact, formatter: formatter)
         end
 
         NODE4_EXT_COMMANDS = %i[transfer].concat(Node::COMMANDS_GEN4).freeze
@@ -374,6 +375,7 @@ module Aspera
           Aspera.error_unreachable_line
         end
 
+        # @param resource_type [Symbol] One of ADMIN_OBJECTS
         def execute_resource_action(resource_type)
           # get path on API, resource type is singular, but api is plural
           resource_class_path =
@@ -391,8 +393,9 @@ module Aspera
           global_operations =  %i[create list]
           supported_operations = %i[show modify]
           supported_operations.push(:delete, *global_operations) unless singleton_object
-          supported_operations.push(:do) if resource_type.eql?(:node)
+          supported_operations.push(:do, :bearer_token) if resource_type.eql?(:node)
           supported_operations.push(:set_pub_key) if resource_type.eql?(:client)
+          supported_operations.push(:shared_folder, :dropbox) if resource_type.eql?(:workspace)
           command = options.get_next_command(supported_operations)
           # require identifier for non global commands
           if !singleton_object && !global_operations.include?(command)
@@ -454,6 +457,60 @@ module Aspera
           when :do
             command_repo = options.get_next_command(NODE4_EXT_COMMANDS)
             return execute_nodegen4_command(command_repo, res_id)
+          when :bearer_token
+            node_api = aoc_api.node_api_from(
+              node_id: res_id,
+              scope:   options.get_next_argument('scope')
+            )
+            return Main.result_text(node_api.oauth.authorization)
+          when :dropbox
+            command_shared = options.get_next_command(%i[list])
+            case command_shared
+            when :list
+              query = options.get_option(:query) || {}
+              res_data = aoc_api.read('dropboxes', query.merge({'workspace_id'=>res_id}))
+              return Main.result_object_list(res_data, fields: %w[id name description])
+            end
+          when :shared_folder
+            query = options.get_option(:query) || Api::AoC.workspace_access(res_id).merge({'admin' => true})
+            shared_folders = aoc_api.read_with_paging("#{resource_instance_path}/permissions", query)[:items]
+            # inside a workspace
+            command_shared = options.get_next_command(%i[list member])
+            case command_shared
+            when :list
+              return Main.result_object_list(shared_folders, fields: %w[id node_name node_id file_id file.path tags.aspera.files.workspace.share_as])
+            when :member
+              shared_folder_id = instance_identifier
+              shared_folder = shared_folders.find{ |i| i['id'].eql?(shared_folder_id)}
+              Aspera.assert(shared_folder)
+              command_shared_member = options.get_next_command(%i[list])
+              case command_shared_member
+              when :list
+                node_api = aoc_api.node_api_from(
+                  node_id: shared_folder['node_id'],
+                  workspace_id: res_id,
+                  workspace_name: nil,
+                  scope: Api::Node::SCOPE_USER
+                )
+                result = node_api.read(
+                  'permissions',
+                  {'file_id' => shared_folder['file_id'], 'tag' => "aspera.files.workspace.id=#{res_id}"}
+                )
+                result.each do |item|
+                  item['member'] = begin
+                    if Api::AoC.workspace_access?(item)
+                      {'name'=>'[Internal permission]'}
+                    else
+                      aoc_api.read("admin/#{item['access_type']}s/#{item['access_id']}") rescue {'name': 'not found'}
+                    end
+                  rescue => e
+                    {'name'=>e.to_s}
+                  end
+                end
+                # TODO : read users and group name and add, if query "include_members"
+                return Main.result_object_list(result, fields: %w[access_type access_id access_level last_updated_at member.name member.email member.system_group_type member.system_group])
+              end
+            end
           else Aspera.error_unexpected_value(command)
           end
         end
@@ -736,7 +793,7 @@ module Aspera
             }
             return result_list('short_links', fields: Formatter.all_but('data'), base_query: list_params) if command.eql?(:list)
             one_id = instance_identifier
-            found = aoc_api.read_with_paging('short_links', query: list_params, formatter: formatter)[:items].find{ |item| item['id'].eql?(one_id)}
+            found = aoc_api.read_with_paging('short_links', list_params, formatter: formatter)[:items].find{ |item| item['id'].eql?(one_id)}
             raise Cli::BadIdentifier.new('Short link', one_id) if found.nil?
             return Main.result_single_object(found, fields: Formatter.all_but('data'))
           when :modify
@@ -886,7 +943,7 @@ module Aspera
                 # enforce workspace id from link (should be already ok, but in case user wanted to override)
                 package_data['workspace_id'] = aoc_api.public_link['data']['workspace_id']
               end
-              package_data['encryption_at_rest'] = true if transfer.option_transfer_spec['content_protection'].eql?('encrypt')
+              package_data['encryption_at_rest'] = true if transfer.user_transfer_spec['content_protection'].eql?('encrypt')
               # 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]))
@@ -921,13 +978,8 @@ module Aspera
               end
               # download all files, or specified list only
               ts_paths = transfer.ts_source_paths(default: ['.'])
-              per_package_def = options.get_option(:package_folder)
-              unless per_package_def.nil?
-                raise Cli::BadArgument, "Invalid package folder option : #{per_package_def}" unless per_package_def =~ /\A([^+]+)(?:\+([^?]+)(\?)?)?\z/
-                per_package_field1 = Regexp.last_match(1)
-                per_package_field2 = Regexp.last_match(2)
-                per_package_sub_always = Regexp.last_match(3).nil?
-              end
+              per_package_def = options.get_option(:package_folder).symbolize_keys
+              save_metadata = per_package_def.delete(:inf)
               # get value outside of loop
               destination_folder = transfer.destination_folder(Transfer::Spec::DIRECTION_RECEIVE)
               result_transfer = []
@@ -943,23 +995,14 @@ module Aspera
                   Transfer::Spec::DIRECTION_RECEIVE,
                   {'paths'=> ts_paths}
                 )
-                unless per_package_def.nil?
-                  # folder based on first field
-                  folder = File.join(
-                    destination_folder,
-                    Environment.instance.sanitized_filename(package_info[per_package_field1])
-                  )
-                  transfer.option_transfer_spec['destination_root'] = self.class.unique_folder(
-                    folder,
-                    extension: per_package_field2.eql?('seq') ? :seq : package_info[per_package_field2],
-                    always: per_package_sub_always
-                  )
-                end
-                formatter.display_status(%Q{Downloading package: [#{package_info['id']}] "#{package_info['name']}" to [#{destination_folder}]})
+                transfer.user_transfer_spec['destination_root'] = self.class.unique_folder(package_info, destination_folder, **per_package_def) unless per_package_def.empty?
+                dest_folder = transfer.user_transfer_spec['destination_root'] || destination_folder
+                formatter.display_status(%Q{Downloading package: [#{package_info['id']}] "#{package_info['name']}" to [#{dest_folder}]})
                 statuses = transfer.start(
                   transfer_spec,
                   rest_token: package_node_api
                 )
+                File.write(File.join(dest_folder, "#{package_id}.info.json"), package_info.to_json) if save_metadata
                 result_transfer.push({'package' => package_id, Main::STATUS_FIELD => statuses})
                 # update skip list only if all transfer sessions completed
                 if skip_ids_persistency && TransferAgent.session_status(statuses).eql?(:success)

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

@@ -18,15 +18,22 @@ module Aspera
         MAX_ITEMS = 'max'
         # Special query parameter: `pmax`: max number of pages for list command
         MAX_PAGES = 'pmax'
-        # Special identifier format: look for this name to find where supported
-        REGEX_LOOKUP_ID_BY_FIELD = /^%([^:]+):(.*)$/
 
         class << self
           def declare_options(options)
-            options.declare(:query, 'Additional filter for for some commands (list/delete)', types: [Hash, Array])
+            options.declare(:query, 'Additional filter for for some commands (list/delete)', allowed: [Hash, Array, NilClass])
             options.declare(:property, 'Name of property to set (modify operation)')
-            options.declare(:bulk, 'Bulk operation (only some)', values: :bool, default: :no)
-            options.declare(:bfail, 'Bulk operation error handling', values: :bool, default: :yes)
+            options.declare(:bulk, 'Bulk operation (only some)', allowed: Allowed::TYPES_BOOLEAN, default: false)
+            options.declare(:bfail, 'Bulk operation error handling', allowed: Allowed::TYPES_BOOLEAN, default: true)
+          end
+
+          # @return [Hash,NilClass] `{field:,value:}` if identifier is a percent selector, else `nil`
+          def percent_selector(identifier)
+            Aspera.assert_type(identifier, String)
+            if (m = identifier.match(REGEX_LOOKUP_ID_BY_FIELD))
+              return {field: m[1], value: ExtendedValue.instance.evaluate(m[2], context: "percent selector: #{m[1]}")}
+            end
+            return
           end
         end
 
@@ -41,10 +48,15 @@ module Aspera
         # Global objects
         attr_reader :context
 
+        # @return [Manager]
         def options; @context.options; end
+        # @return [TransferAgent]
         def transfer; @context.transfer; end
+        # @return [Config]
         def config; @context.config; end
+        # @return [Formatter]
         def formatter; @context.formatter; end
+        # @return [PersistencyFolder]
         def persistency; @context.persistency; end
 
         def add_manual_header(has_options = true)
@@ -55,26 +67,17 @@ module Aspera
           options.parser.separator('OPTIONS:') if has_options
         end
 
-        # Must be called AFTER the instance action:
-        # ... folder browse _call_instance_identifier
+        # Resource identifier as positional parameter
         #
         # @param description [String] description of the identifier
-        # @param as_option   [Symbol] option name to use if identifier is an option
         # @param block       [Proc] block to search for identifier based on attribute value
         # @return   [String, Array] identifier or list of ids
-        def instance_identifier(description: 'identifier', as_option: nil, &block)
-          if as_option.nil?
-            res_id = options.get_next_argument(description, multiple: options.get_option(:bulk)) if res_id.nil?
-          else
-            res_id = options.get_option(as_option)
-          end
+        def instance_identifier(description: 'identifier', &block)
+          res_id = options.get_next_argument(description, multiple: options.get_option(:bulk)) if res_id.nil?
           # Can be an Array
-          if res_id.is_a?(String) && (m = res_id.match(REGEX_LOOKUP_ID_BY_FIELD))
-            if block
-              res_id = yield(m[1], ExtendedValue.instance.evaluate(m[2]))
-            else
-              raise Cli::BadArgument, "Percent syntax for #{description} not supported in this context"
-            end
+          if res_id.is_a?(String) && (m = Base.percent_selector(res_id))
+            Aspera.assert(block, type: Cli::BadArgument){"Percent syntax for #{description} not supported in this context"}
+            res_id = yield(m[:field], m[:value])
           end
           return res_id
         end
@@ -172,12 +175,11 @@ module Aspera
             if !delete_style.nil?
               one_res_id = [one_res_id] unless one_res_id.is_a?(Array)
               Aspera.assert_type(one_res_id, Array, type: Cli::BadArgument)
-              api.call(
-                operation:    'DELETE',
-                subpath:      entity,
+              api.delete(
+                entity,
+                nil,
                 content_type: Rest::MIME_JSON,
-                body:         {delete_style => one_res_id},
-                headers:      {'Accept' => Rest::MIME_JSON}
+                body:         {delete_style => one_res_id}
               )
               return Main.result_status('deleted')
             end
@@ -192,11 +194,10 @@ module Aspera
               data, total = list_entities_limit_offset_total_count(api: api, entity:, items_key: items_key, query: query_read_delete(default: list_query))
               return Main.result_object_list(data, total: total, fields: display_fields)
             end
-            resp = api.call(operation: 'GET', subpath: entity, headers: {'Accept' => Rest::MIME_JSON}, query: query_read_delete)
-            return Main.result_empty if resp[:http].code == '204'
-            data = resp[:data]
+            data, http = api.read(entity, query_read_delete, ret: :both)
+            return Main.result_empty if http.code == '204'
             # TODO: not generic : which application is this for ?
-            if resp[:http]['Content-Type'].start_with?('application/vnd.api+json')
+            if http['Content-Type'].start_with?('application/vnd.api+json')
               Log.log.debug('is vnd.api')
               data = data[entity]
             end
@@ -223,9 +224,8 @@ module Aspera
 
         # Query parameters in URL suitable for REST: list/GET and delete/DELETE
         def query_read_delete(default: nil)
-          query = options.get_option(:query)
           # Dup default, as it could be frozen
-          query = default.dup if query.nil?
+          query = options.get_option(:query) || default.dup
           Log.log.debug{"query_read_delete=#{query}".bg_red}
           begin
             # Check it is suitable
@@ -249,7 +249,7 @@ module Aspera
           value = default if value.nil?
           unless type.nil?
             type = [type] unless type.is_a?(Array)
-            Aspera.assert(type.all?(Class)){"check types must be a Class, not #{type.map(&:class).join(',')}"}
+            Aspera.assert_array_all(type, Class){'check types'}
             if bulk
               Aspera.assert_type(value, Array, type: Cli::BadArgument)
               value.each do |v|
@@ -263,10 +263,10 @@ module Aspera
         end
 
         # Get a (full or partial) list of all entities of a given type with query: offset/limit
-        # @param `api`       [Rest]          the API object
-        # @param `entity`    [String,Symbol] the API endpoint of entity to list
-        # @param `items_key` [String]        key in the result to get the list of items
-        # @param `query`     [Hash,nil]      additional query parameters
+        # @param api       [Rest]          API object
+        # @param entity    [String,Symbol] API endpoint of entity to list
+        # @param items_key [String]        Key in the result to get the list of items (Default: same as `entity`)
+        # @param query     [Hash,nil]      Additional query parameters
         # @return [Array] items, total_count
         def list_entities_limit_offset_total_count(
           api:,
@@ -309,26 +309,39 @@ module Aspera
           return result, total_count
         end
 
-        # Lookup an entity id from its name
-        # @param entity    [String] the type of entity to lookup, by default it is the path, and it is also the field name in result
-        # @param value     [String] the value to lookup
-        # @param field     [String] the field to match, by default it is 'name'
-        # @param items_key [String] key in the result to get the list of items (override entity)
-        # @param query     [Hash]   additional query parameters
+        # Lookup an entity id from its name.
+        # Uses query `q` if `query` is `:default` and `field` is `name`.
+        # @param entity    [String] Type of entity to lookup, by default it is the path, and it is also the field name in result
+        # @param value     [String] Value to lookup
+        # @param field     [String] Field to match, by default it is `'name'`
+        # @param items_key [String] Key in the result to get the list of items (override entity)
+        # @param query     [Hash]   Additional query parameters (Default: `:default`)
         def lookup_entity_by_field(api:, entity:, value:, field: 'name', items_key: nil, query: :default)
           if query.eql?(:default)
             Aspera.assert(field.eql?('name')){'Default query is on name only'}
             query = {'q'=> value}
           end
-          found = list_entities_limit_offset_total_count(api: api, entity: entity, items_key: items_key, query: query).first.select{ |i| i[field].eql?(value)}
-          case found.length
-          when 0 then raise "No #{entity} with #{field} = #{value}"
-          when 1 then return found.first
-          else raise "Found #{found.length} #{entity} with #{field} = #{value}"
-          end
+          lookup_entity_generic(entity: entity, field: field, value: value){list_entities_limit_offset_total_count(api: api, entity: entity, items_key: items_key, query: query).first}
+        end
+
+        # Lookup entity by field and value. Extract single result from list of result returned by block.
+        # @param entity    [String] Type of entity to lookup, by default it is the path, and it is also the field name in result
+        # @param value     [String] Value to lookup
+        # @param field     [String] Field to match, by default it is `'name'`
+        # @param block     [Proc]   Get list of entity matching query.
+        def lookup_entity_generic(entity:, value:, field: 'name', &block)
+          Aspera.assert(block_given?)
+          found = yield
+          Aspera.assert_array_all(found, Hash)
+          found = found.select{ |i| i[field].eql?(value)}
+          return found.first if found.length.eql?(1)
+          raise Cli::BadIdentifier.new(entity, value, field: field, count: found.length)
         end
+
         PER_PAGE_DEFAULT = 1000
-        private_constant :PER_PAGE_DEFAULT
+        # Percent selector: select by this field for this value
+        REGEX_LOOKUP_ID_BY_FIELD = /^%([^:]+):(.*)$/
+        private_constant :PER_PAGE_DEFAULT, :REGEX_LOOKUP_ID_BY_FIELD
       end
     end
   end