aspera-cli 4.22.0 → 4.24.0

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

@@ -8,6 +8,10 @@ module Aspera
     module Plugins
       class Console < Cli::BasicAuthPlugin
         STANDARD_PATH = '/aspera/console'
+        DEFAULT_FILTER_AGE_SECONDS = 24 * 3600
+        EXPR_RE = /\A(\S+) (\S+) (.*)\z/
+        private_constant :STANDARD_PATH, :DEFAULT_FILTER_AGE_SECONDS, :EXPR_RE
+
         class << self
           def detect(address_or_url)
             address_or_url = "https://#{address_or_url}" unless address_or_url.match?(%r{^[a-z]{1,6}://})
@@ -21,7 +25,8 @@ module Aspera
               test_page = api.call(
                 operation: 'GET',
                 subpath:   test_endpoint,
-                query:     {local: true})
+                query:     {local: true}
+              )
               next unless test_page[:http].body.include?('Aspera Console')
               version = 'unknown'
               if (m = test_page[:http].body.match(/\(v([1-9]\..*)\)/))
@@ -37,7 +42,7 @@ module Aspera
               Log.log.debug{"detect error: #{e}"}
             end
             raise error if error
-            return nil
+            return
           end
 
           # @param object [Plugin] An instance of this class
@@ -54,14 +59,22 @@ module Aspera
             }
           end
         end
-        DEFAULT_FILTER_AGE_SECONDS = 3 * 3600
-        private_constant :DEFAULT_FILTER_AGE_SECONDS
-        def initialize(**env)
+
+        def initialize(**_)
           super
-          time_now = Time.now
-          options.declare(:filter_from, 'Only after date', values: :date, default: Manager.time_to_string(time_now - DEFAULT_FILTER_AGE_SECONDS))
-          options.declare(:filter_to, 'Only before date', values: :date, default: Manager.time_to_string(time_now))
-          options.parse_options!
+        end
+
+        def parse_extended_filter(filter, query)
+          raise BadArgument, "Invalid filter syntax: #{filter}, shall be (field op val)and(field op val)..." unless filter.start_with?('(') && filter.end_with?(')')
+          filter[1..-2].split(')and(').each_with_index do |expr, i|
+            m = expr.match(EXPR_RE)
+            raise BadArgument, "Invalid expression: #{expr}, shall be: <field> <op> <val>" unless m
+            t = m.captures
+            i += 1
+            query["filter#{i}"] = t[0]
+            query["comp#{i}"]   = t[1]
+            query["val#{i}"]    = t[2]
+          end
         end
 
         ACTIONS = %i[transfer health].freeze
@@ -89,20 +102,38 @@ module Aspera
                 return Main.result_object_list(api_console.read('smart_transfers'))
               when :submit
                 smart_id = options.get_next_argument('smart_id')
-                params = options.get_next_argument('transfer parameters')
+                params = options.get_next_argument('transfer parameters', validation: Hash)
                 return Main.result_object_list(api_console.create("smart_transfers/#{smart_id}", params))
               end
             when :current
-              command = options.get_next_command([:list])
+              command = options.get_next_command(%i[list show files start pause cancel resume rerun change_rate change_policy move_forwards move_back])
               case command
               when :list
-                return {
-                  type:   :object_list,
-                  data:   api_console.read('transfers', {
-                    'from' => options.get_option(:filter_from, mandatory: true),
-                    'to'   => options.get_option(:filter_to, mandatory: true)
-                  }),
-                  fields: %w[id contact name status]}
+                # https://developer.ibm.com/apis/catalog/aspera--aspera-console-rest-api/Developer+Guides#transfer-list
+                query = query_read_delete(default: {})
+                if query['from'].nil? && query['to'].nil?
+                  time_now = Time.now
+                  query['from'] = Manager.time_to_string(time_now - DEFAULT_FILTER_AGE_SECONDS)
+                  query['to'] = Manager.time_to_string(time_now)
+                end
+                if (filter = query.delete('filter'))
+                  parse_extended_filter(filter, query)
+                end
+                return Main.result_object_list(
+                  api_console.read('transfers', query),
+                  fields: %w[id contact name status]
+                )
+              when :show
+                transfer_id = instance_identifier(description: 'transfer ID')
+                return Main.result_single_object(api_console.read("transfers/#{transfer_id}"))
+              when :files
+                transfer_id = instance_identifier(description: 'transfer ID')
+                query = query_read_delete(default: {})
+                query['limit'] ||= 100
+                return Main.result_object_list(api_console.read("transfers/#{transfer_id}/files", query))
+              when :start, :pause, :cancel, :resume, :rerun, :change_rate, :change_policy, :move_forwards, :move_back
+                transfer_id = instance_identifier(description: 'transfer ID')
+                return Main.result_single_object(api_console.update("transfers/#{transfer_id}/#{command}", query_read_delete))
               end
             end
           end

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

@@ -9,7 +9,7 @@ module Aspera
   module Cli
     module Plugins
       class Cos < Cli::Plugin
-        def initialize(**env)
+        def initialize(**_)
           super
           options.declare(:bucket, 'Bucket name')
           options.declare(:endpoint, 'Storage endpoint (URL)')
@@ -36,15 +36,15 @@ module Aspera
               endpoint: options.get_option(:endpoint)
             }
             if service_credentials.nil?
-              Aspera.assert(!cos_node_params[:endpoint].nil?, exception_class: Cli::BadArgument){'endpoint required when service credentials not provided'}
+              Aspera.assert(!cos_node_params[:endpoint].nil?, type: Cli::BadArgument){'endpoint required when service credentials not provided'}
               cos_node_params[:api_key] = options.get_option(:apikey, mandatory: true)
               cos_node_params[:instance_id] = options.get_option(:crn, mandatory: true)
             else
-              Aspera.assert(cos_node_params[:endpoint].nil?, exception_class: Cli::BadArgument){'endpoint not allowed when service credentials provided'}
+              Aspera.assert(cos_node_params[:endpoint].nil?, type: Cli::BadArgument){'endpoint not allowed when service credentials provided'}
               cos_node_params.merge!(Api::CosNode.parameters_from_svc_credentials(service_credentials, options.get_option(:region, mandatory: true)))
             end
             api_node = Api::CosNode.new(**cos_node_params)
-            node_plugin = Node.new(**init_params, api: api_node)
+            node_plugin = Node.new(context: context, api: api_node)
             command = options.get_next_command(Node::COMMANDS_COS)
             return node_plugin.execute_action(command)
           end

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

@@ -38,7 +38,7 @@ module Aspera
         PUB_LINK_EXTERNAL_MATCH = 'external_deliveries/'
         STANDARD_PATH = '/aspera/faspex'
         HEADER_FASPEX_VERSION = 'X-IBM-Aspera'
-        private_constant(*%i[KEY_NODE KEY_PATH PACKAGE_MATCH_FIELD ATOM_MAILBOXES ATOM_PARAMS ATOM_EXT_PARAMS PUB_LINK_EXTERNAL_MATCH HEADER_FASPEX_VERSION])
+        private_constant :KEY_NODE, :KEY_PATH, :PACKAGE_MATCH_FIELD, :ATOM_MAILBOXES, :ATOM_PARAMS, :ATOM_EXT_PARAMS, :PUB_LINK_EXTERNAL_MATCH, :HEADER_FASPEX_VERSION
 
         class << self
           def detect(address_or_url)
@@ -71,7 +71,7 @@ module Aspera
               Log.log.debug{"detect error: #{e}"}
             end
             raise error if error
-            return nil
+            return
           end
 
           # @param object [Plugin] An instance of this class
@@ -91,7 +91,7 @@ module Aspera
           # extract elements from faspex public link
           def get_link_data(public_url)
             public_uri = URI.parse(public_url)
-            Aspera.assert(m = public_uri.path.match(%r{^(.*)/(external.*)$}), exception_class: Cli::BadArgument){'Public link does not match Faspex format'}
+            Aspera.assert(m = public_uri.path.match(%r{^(.*)/(external.*)$}), type: Cli::BadArgument){'Public link does not match Faspex format'}
             base = m[1]
             subpath = m[2]
             port_add = public_uri.port.eql?(public_uri.default_port) ? '' : ":#{public_uri.port}"
@@ -100,7 +100,7 @@ module Aspera
               subpath:  subpath,
               query:    Rest.query_to_h(public_uri.query)
             }
-            Log.log.debug{Log.dump('link data', result)}
+            Log.dump(:link_data, result)
             return result
           end
 
@@ -108,7 +108,7 @@ module Aspera
           def get_fasp_uri_from_entry(entry, raise_no_link: true)
             unless entry.key?('link')
               raise Cli::BadArgument, 'package has no link (deleted?)' if raise_no_link
-              return nil
+              return
             end
             result = entry['link'].find{ |e| e['rel'].eql?('package')}['href']
             return result
@@ -122,7 +122,7 @@ module Aspera
           end
         end
 
-        def initialize(**env)
+        def initialize(**_)
           super
           @api_v3 = nil
           @api_v4 = nil
@@ -136,9 +136,7 @@ module Aspera
         end
 
         def api_v3
-          if @api_v3.nil?
-            @api_v3 = basic_auth_api
-          end
+          @api_v3 = basic_auth_api if @api_v3.nil?
           return @api_v3
         end
 
@@ -154,7 +152,8 @@ module Aspera
                 auth:         {type: :basic, username: options.get_option(:username, mandatory: true), password: options.get_option(:password, mandatory: true)},
                 scope:        'admin',
                 grant_type:   'password'
-              })
+              }
+            )
           end
           return @api_v4
         end
@@ -187,9 +186,10 @@ module Aspera
               operation: 'GET',
               subpath:   "#{mailbox}.atom",
               headers:   {'Accept' => 'application/xml'},
-              query:     mailbox_query)[:http].body
+              query:     mailbox_query
+            )[:http].body
             box_data = XmlSimple.xml_in(atom_xml, {'ForceArray' => %w[entry field link to]})
-            Log.log.debug{Log.dump(:box_data, box_data)}
+            Log.dump(:box_data, box_data)
             items = box_data.key?('entry') ? box_data['entry'] : []
             Log.log.debug{"new items: #{items.count}"}
             # it is the end if page is empty
@@ -240,9 +240,7 @@ module Aspera
           delivery_info = package_create_params['delivery']
           # pub link user
           link_data = self.class.get_link_data(public_link_url)
-          if !['external/submissions/new', 'external/dropbox_submissions/new'].include?(link_data[:subpath])
-            raise Cli::BadArgument, "pub link is #{link_data[:subpath]}, expecting external/submissions/new"
-          end
+          raise Cli::BadArgument, "pub link is #{link_data[:subpath]}, expecting external/submissions/new" if !['external/submissions/new', 'external/dropbox_submissions/new'].include?(link_data[:subpath])
           create_path = link_data[:subpath].split('/')[0..-2].join('/')
           package_create_params[:passcode] = link_data[:query]['passcode']
           delivery_info[:transfer_type] = 'connect'
@@ -267,7 +265,7 @@ module Aspera
           begin
             package_creation_data = JSON.parse("[#{package_creation_data}]")
           rescue JSON::ParserError # => e
-            raise 'Unexpected response: missing metadata ?'
+            raise Aspera::Error, 'Unexpected response: missing metadata ?'
           end
           return package_creation_data.first
         end
@@ -293,14 +291,10 @@ module Aspera
               delivery_id = instance_identifier
               return Main.result_single_object(mailbox_filtered_entries(stop_at_id: delivery_id).find{ |p| p[PACKAGE_MATCH_FIELD].eql?(delivery_id)})
             when :list
-              return {
-                type:   :object_list,
-                data:   mailbox_filtered_entries,
-                fields: [PACKAGE_MATCH_FIELD, 'title', 'items']
-              }
+              return Main.result_object_list(mailbox_filtered_entries, fields: [PACKAGE_MATCH_FIELD, 'title', 'items'])
             when :send
               delivery_info = options.get_option(:delivery_info, mandatory: true)
-              Aspera.assert_type(delivery_info, Hash, exception_class: Cli::BadArgument){'delivery_info'}
+              Aspera.assert_type(delivery_info, Hash, type: Cli::BadArgument){'delivery_info'}
               # actual parameter to faspex API
               package_create_params = {'delivery' => delivery_info}
               public_link_url = options.get_option(:link)
@@ -310,7 +304,7 @@ module Aspera
                 first_source = delivery_info['sources'].first
                 first_source['paths'].concat(transfer.source_list)
                 source_id = instance_identifier(as_option: :remote_source) do |field, value|
-                  Aspera.assert(field.eql?('name'), exception_class: Cli::BadArgument){'only name as selector, or give id'}
+                  Aspera.assert(field.eql?('name'), type: Cli::BadArgument){'only name as selector, or give id'}
                   source_list = api_v3.read('source_shares')['items']
                   self.class.get_source_id_by_name(value, source_list)
                 end
@@ -327,7 +321,7 @@ module Aspera
               else # public link
                 transfer_spec = send_public_link_to_ts(public_link_url, package_create_params)
               end
-              # Log.log.debug{Log.dump('transfer_spec',transfer_spec)}
+              # Log.dump(:transfer_spec,transfer_spec)
               return Main.result_transfer(transfer.start(transfer_spec))
             when :receive
               link_url = options.get_option(:link)
@@ -346,11 +340,12 @@ module Aspera
                       options.get_option(:url, mandatory: true),
                       options.get_option(:username, mandatory: true),
                       options.get_option(:box, mandatory: true).to_s
-                    ]))
+                    ])
+                  )
                 end
                 # get command line parameters
                 delivery_id = instance_identifier
-                raise 'empty id' if delivery_id.empty?
+                Aspera.assert(!delivery_id.empty?){'empty id'}
                 recipient = options.get_option(:recipient)
                 if delivery_id.eql?(SpecialValues::ALL)
                   pkg_id_uri = mailbox_filtered_entries.map{ |i| {id: i[PACKAGE_MATCH_FIELD], uri: self.class.get_fasp_uri_from_entry(i, raise_no_link: false)}}
@@ -378,22 +373,21 @@ module Aspera
                 pkg_id_uri = [{id: 'package', uri: link_url}]
               else
                 link_data = self.class.get_link_data(link_url)
-                if !link_data[:subpath].start_with?(PUB_LINK_EXTERNAL_MATCH)
-                  raise Cli::BadArgument, "Pub link is #{link_data[:subpath]}. Expecting #{PUB_LINK_EXTERNAL_MATCH}"
-                end
+                raise Cli::BadArgument, "Pub link is #{link_data[:subpath]}. Expecting #{PUB_LINK_EXTERNAL_MATCH}" if !link_data[:subpath].start_with?(PUB_LINK_EXTERNAL_MATCH)
                 # NOTE: unauthenticated API (authorization is in url params)
                 api_public_link = Rest.new(base_url: link_data[:base_url])
                 package_creation_data = api_public_link.call(
                   operation: 'GET',
                   subpath:   link_data[:subpath],
                   headers:   {'Accept' => 'application/xml'},
-                  query:     {passcode: link_data[:query]['passcode']})
+                  query:     {passcode: link_data[:query]['passcode']}
+                )
                 if !package_creation_data[:http].body.start_with?('<?xml ')
                   Environment.instance.open_uri(link_url)
                   raise Cli::Error, 'Unexpected response: package not found ?'
                 end
                 package_entry = XmlSimple.xml_in(package_creation_data[:http].body, {'ForceArray' => false})
-                Log.log.debug{Log.dump(:package_entry, package_entry)}
+                Log.dump(:package_entry, package_entry)
                 transfer_uri = self.class.get_fasp_uri_from_entry(package_entry)
                 pkg_id_uri = [{id: package_entry['id'], uri: transfer_uri}]
               end
@@ -401,7 +395,7 @@ module Aspera
               # TODO : remove ids from skip not present in inbox to avoid growing too big
               # skip_ids_data.select!{|id|pkg_id_uri.select{|p|p[:id].eql?(id)}}
               pkg_id_uri.reject!{ |i| skip_ids_data.include?(i[:id])}
-              Log.log.debug{Log.dump(:pkg_id_uri, pkg_id_uri)}
+              Log.dump(:pkg_id_uri, pkg_id_uri)
               return Main.result_status('no new package') if pkg_id_uri.empty?
               result_transfer = []
               pkg_id_uri.each do |id_uri|
@@ -442,41 +436,41 @@ module Aspera
               return Main.result_object_list(source_list)
             else # :info :node
               source_id = instance_identifier do |field, value|
-                Aspera.assert(field.eql?('name'), exception_class: Cli::BadArgument){'only name as selector, or give id'}
+                Aspera.assert(field.eql?('name'), type: Cli::BadArgument){'only name as selector, or give id'}
                 self.class.get_source_id_by_name(value, source_list)
               end.to_i
               selected_source = source_list.find{ |i| i['id'].eql?(source_id)}
-              raise 'No such source' if selected_source.nil?
+              raise BadArgument, 'No such source' if selected_source.nil?
               source_name = selected_source['name']
               source_hash = options.get_option(:storage, mandatory: true)
               # check value of option
-              Aspera.assert_type(source_hash, Hash, exception_class: Cli::Error){'storage option'}
+              Aspera.assert_type(source_hash, Hash, type: Cli::Error){'storage option'}
               source_hash.each do |name, storage|
-                Aspera.assert_type(storage, Hash, exception_class: Cli::Error){"storage '#{name}'"}
+                Aspera.assert_type(storage, Hash, type: Cli::Error){"storage '#{name}'"}
                 [KEY_NODE, KEY_PATH].each do |key|
-                  Aspera.assert(storage.key?(key), exception_class: Cli::Error){"storage '#{name}' must have a '#{key}'"}
+                  Aspera.assert(storage.key?(key), type: Cli::Error){"storage '#{name}' must have a '#{key}'"}
                 end
               end
-              if !source_hash.key?(source_name)
-                raise Cli::Error, "No such storage in config file: \"#{source_name}\" in [#{source_hash.keys.join(', ')}]"
-              end
+              raise Cli::Error, "No such storage in config file: \"#{source_name}\" in [#{source_hash.keys.join(', ')}]" if !source_hash.key?(source_name)
               source_info = source_hash[source_name]
-              Log.log.debug{Log.dump(:source_info, source_info)}
+              Log.dump(:source_info, source_info)
               case command_source
               when :info
                 return Main.result_single_object(source_info)
               when :node
                 node_config = ExtendedValue.instance.evaluate(source_info[KEY_NODE])
                 Log.log.debug{"node=#{node_config}"}
-                Aspera.assert_type(node_config, Hash, exception_class: Cli::Error){source_info[KEY_NODE]}
+                Aspera.assert_type(node_config, Hash, type: Cli::Error){source_info[KEY_NODE]}
                 api_node = Rest.new(
                   base_url: node_config['url'],
                   auth:     {
                     type:     :basic,
                     username: node_config['username'],
-                    password: node_config['password']})
+                    password: node_config['password']
+                  }
+                )
                 command = options.get_next_command(Node::COMMANDS_FASPEX)
-                return Node.new(**init_params, api: api_node, prefix_path: source_info[KEY_PATH]).execute_action(command)
+                return Node.new(context: context, api: api_node, prefix_path: source_info[KEY_PATH]).execute_action(command)
               end
             end
           when :me
@@ -493,21 +487,21 @@ module Aspera
             command = options.get_next_command(%i[package dropbox dmembership workgroup wmembership user metadata_profile])
             case command
             when :dropbox
-              return entity_action(api_v4, 'admin/dropboxes', display_fields: %w[id e_wg_name e_wg_desc created_at])
+              return entity_execute(api: api_v4, entity: 'admin/dropboxes', display_fields: %w[id e_wg_name e_wg_desc created_at])
             when :dmembership
-              return entity_action(api_v4, 'dropbox_memberships')
+              return entity_execute(api: api_v4, entity: 'dropbox_memberships')
             when :workgroup
-              return entity_action(api_v4, 'admin/workgroups', display_fields: %w[id e_wg_name e_wg_desc created_at])
+              return entity_execute(api: api_v4, entity: 'admin/workgroups', display_fields: %w[id e_wg_name e_wg_desc created_at])
             when :wmembership
-              return entity_action(api_v4, 'workgroup_memberships')
+              return entity_execute(api: api_v4, entity: 'workgroup_memberships')
             when :user
-              return entity_action(api_v4, 'users', display_fields: %w[id name first_name last_name])
+              return entity_execute(api: api_v4, entity: 'users', display_fields: %w[id name first_name last_name])
             when :metadata_profile
-              return entity_action(api_v4, 'metadata_profiles')
+              return entity_execute(api: api_v4, entity: 'metadata_profiles')
             when :package
               pkg_box_type = options.get_next_command([:users])
               pkg_box_id = instance_identifier
-              return entity_action(api_v4, "#{pkg_box_type}/#{pkg_box_id}/packages")
+              return entity_execute(api: api_v4, entity: "#{pkg_box_type}/#{pkg_box_id}/packages")
             end
           when :address_book
             result = api_v3.read('address-book', {'format' => 'json', 'count' => 100_000})