aspera-cli 4.16.0 → 4.17.0

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

@@ -6,19 +6,19 @@ require 'aspera/nagios'
 module Aspera
   module Cli
     module Plugins
-      class Console < Aspera::Cli::BasicAuthPlugin
+      class Console < Cli::BasicAuthPlugin
         STANDARD_PATH = '/aspera/console'
         class << self
           def detect(address_or_url)
             address_or_url = "https://#{address_or_url}" unless address_or_url.match?(%r{^[a-z]{1,6}://})
             urls = [address_or_url]
             urls.push("#{address_or_url}#{STANDARD_PATH}") unless address_or_url.end_with?(STANDARD_PATH)
-
+            error = nil
             urls.each do |base_url|
               next unless base_url.start_with?('https://')
               api = Rest.new(base_url: base_url, redirect_max: 2)
               test_endpoint = 'login'
-              test_page = api.call({operation: 'GET', subpath: test_endpoint, url_params: {local: true}})
+              test_page = api.call(operation: 'GET', subpath: test_endpoint, url_params: {local: true})
               next unless test_page[:http].body.include?('Aspera Console')
               version = 'unknown'
               if (m = test_page[:http].body.match(/\(v([1-9]\..*)\)/))
@@ -30,8 +30,10 @@ module Aspera
                 url:     url[0..url.index(test_endpoint) - 2]
               }
             rescue StandardError => e
+              error = e
               Log.log.debug{"detect error: #{e}"}
             end
+            raise error if error
             return nil
           end
 
@@ -49,8 +51,8 @@ module Aspera
         end
         DEFAULT_FILTER_AGE_SECONDS = 3 * 3600
         private_constant :DEFAULT_FILTER_AGE_SECONDS
-        def initialize(env)
-          super(env)
+        def initialize(**env)
+          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))
@@ -83,7 +85,7 @@ module Aspera
               when :submit
                 smart_id = options.get_next_argument('smart_id')
                 params = options.get_next_argument('transfer parameters')
-                return {type: :object_list, data: api_console.create('smart_transfers/' + smart_id, params)[:data]}
+                return {type: :object_list, data: api_console.create("smart_transfers/#{smart_id}", params)[:data]}
               end
             when :current
               command = options.get_next_command([:list])

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

@@ -2,22 +2,22 @@
 
 require 'aspera/cli/plugin'
 require 'aspera/cli/plugins/node'
-require 'aspera/cos_node'
+require 'aspera/api/cos_node'
 require 'aspera/assert'
 
 module Aspera
   module Cli
     module Plugins
-      class Cos < Aspera::Cli::Plugin
-        def initialize(env)
-          super(env)
+      class Cos < Cli::Plugin
+        def initialize(**env)
+          super
           options.declare(:bucket, 'Bucket name')
-          options.declare(:endpoint, 'Storage endpoint url')
+          options.declare(:endpoint, 'Storage endpoint (URL)')
           options.declare(:apikey, 'Storage API key')
-          options.declare(:crn, 'Resource instance id')
+          options.declare(:crn, 'Resource instance id (CRN)')
           options.declare(:service_credentials, 'IBM Cloud service credentials', types: Hash)
           options.declare(:region, 'Storage region')
-          options.declare(:identity, "Authentication url (#{CosNode::IBM_CLOUD_TOKEN_URL})", default: CosNode::IBM_CLOUD_TOKEN_URL)
+          options.declare(:identity, "Authentication URL (#{Api::CosNode::IBM_CLOUD_TOKEN_URL})", default: Api::CosNode::IBM_CLOUD_TOKEN_URL)
           options.parse_options!
         end
 
@@ -27,22 +27,23 @@ module Aspera
           command = options.get_next_command(ACTIONS)
           case command
           when :node
-            bucket_name = options.get_option(:bucket, mandatory: true)
             # get service credentials, Hash, e.g. @json:@file:...
             service_credentials = options.get_option(:service_credentials)
-            storage_endpoint = options.get_option(:endpoint)
-            assert(service_credentials.nil? ^ storage_endpoint.nil?, exception_class: Cli::BadArgument){'endpoint and service_credentials are mutually exclusive'}
+            cos_node_params = {
+              auth_url: options.get_option(:identity, mandatory: true),
+              bucket:   options.get_option(:bucket, mandatory: true),
+              endpoint: options.get_option(:endpoint)
+            }
             if service_credentials.nil?
-              service_api_key = options.get_option(:apikey, mandatory: true)
-              instance_id = options.get_option(:crn, mandatory: true)
+              Aspera.assert(!cos_node_params[:endpoint].nil?, exception_class: 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
-              params = CosNode.parameters_from_svc_credentials(service_credentials, options.get_option(:region, mandatory: true))
-              storage_endpoint = params[:storage_endpoint]
-              service_api_key = params[:service_api_key]
-              instance_id = params[:instance_id]
+              Aspera.assert(cos_node_params[:endpoint].nil?, exception_class: 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 = CosNode.new(bucket_name, storage_endpoint, instance_id, service_api_key, options.get_option(:identity, mandatory: true))
-            node_plugin = Node.new(@agents, api: api_node)
+            api_node = Api::CosNode.new(**cos_node_params)
+            node_plugin = Node.new(**init_params, 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

@@ -6,8 +6,8 @@ require 'aspera/cli/plugins/node'
 require 'aspera/cli/plugins/config'
 require 'aspera/cli/extended_value'
 require 'aspera/cli/transfer_agent'
-require 'aspera/fasp/uri'
-require 'aspera/fasp/transfer_spec'
+require 'aspera/transfer/uri'
+require 'aspera/transfer/spec'
 require 'aspera/persistency_action_once'
 require 'aspera/open_application'
 require 'aspera/nagios'
@@ -21,7 +21,7 @@ require 'cgi'
 module Aspera
   module Cli
     module Plugins
-      class Faspex < Aspera::Cli::BasicAuthPlugin
+      class Faspex < Cli::BasicAuthPlugin
         # required hash key for source in config
         KEY_NODE = 'node' # value must be hash with url, username, password
         KEY_PATH = 'path' # value must be same sub-path as in Faspex's node
@@ -43,25 +43,32 @@ module Aspera
             address_or_url = "https://#{address_or_url}" unless address_or_url.match?(%r{^[a-z]{1,6}://})
             urls = [address_or_url]
             urls.push("#{address_or_url}#{STANDARD_PATH}") unless address_or_url.end_with?(STANDARD_PATH)
-
+            error = nil
             urls.each do |base_url|
               next unless base_url.start_with?('https://')
               api = Rest.new(base_url: base_url, redirect_max: 1)
               result = api.call(
                 operation:        'POST',
-                subpath:          '',
-                headers:          {'Accept' => 'application/xrds+xml', 'Content-type' => 'text/plain'},
-                text_body_params: '')
+                headers:          {
+                  'Content-type' => 'text/plain',
+                  'Accept'       => 'application/xrds+xml'
+                }
+              )
               # 4.x
               next unless result[:http].body.start_with?('<?xml')
               res_s = XmlSimple.xml_in(result[:http].body, {'ForceArray' => false})
               Log.log.debug{"version: #{result[:http]['X-IBM-Aspera']}"}
               version = res_s['XRD']['application']['version']
               # take redirect if any
-              return {version: version, url: result[:http].uri.to_s}
+              return {
+                version: version,
+                url:     result[:http].uri.to_s
+              }
             rescue StandardError => e
+              error = e
               Log.log.debug{"detect error: #{e}"}
             end
+            raise error if error
             return nil
           end
 
@@ -80,7 +87,7 @@ module Aspera
           # extract elements from faspex public link
           def get_link_data(public_url)
             public_uri = URI.parse(public_url)
-            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.*)$})), exception_class: 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}"
@@ -93,7 +100,7 @@ module Aspera
             return result
           end
 
-          # get Fasp::Uri::SCHEME URI from entry in xml, and fix problems.
+          # get Transfer::Uri::SCHEME URI from entry in xml, and fix problems.
           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
@@ -111,10 +118,10 @@ module Aspera
           end
         end
 
-        def initialize(env)
+        def initialize(**env)
+          super
           @api_v3 = nil
           @api_v4 = nil
-          super(env)
           options.declare(:link, 'Public link for specific operation')
           options.declare(:delivery_info, 'Package delivery information', types: Hash)
           options.declare(:remote_source, 'Remote source for package send (id or %name:)')
@@ -134,16 +141,16 @@ module Aspera
         def api_v4
           if @api_v4.nil?
             faspex_api_base = options.get_option(:url, mandatory: true)
-            @api_v4 = Rest.new({
-              base_url: faspex_api_base + '/api',
+            @api_v4 = Rest.new(
+              base_url: "#{faspex_api_base}/api",
               auth:     {
                 type:         :oauth2,
-                base_url:     faspex_api_base + '/auth/oauth2',
-                auth:         {type: :basic, username: options.get_option(:username, mandatory: true), password: options.get_option(:password, mandatory: true)},
                 grant_method: :generic,
-                generic:      {grant_type: 'password'},
-                scope:        'admin'
-              }})
+                base_url:     "#{faspex_api_base}/auth/oauth2",
+                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
@@ -161,9 +168,9 @@ module Aspera
           max_pages = nil
           result = []
           if !mailbox_query.nil?
-            assert_type(mailbox_query, Hash){'query'}
-            assert((mailbox_query.keys - ATOM_EXT_PARAMS).empty?){"query: supported params: #{ATOM_EXT_PARAMS}"}
-            assert(!(mailbox_query.key?('startIndex') && mailbox_query.key?('page'))){'query: startIndex and page are exclusive'}
+            Aspera.assert_type(mailbox_query, Hash){'query'}
+            Aspera.assert((mailbox_query.keys - ATOM_EXT_PARAMS).empty?){"query: supported params: #{ATOM_EXT_PARAMS}"}
+            Aspera.assert(!(mailbox_query.key?('startIndex') && mailbox_query.key?('page'))){'query: startIndex and page are exclusive'}
             max_items = mailbox_query[MAX_ITEMS]
             mailbox_query.delete(MAX_ITEMS)
             max_pages = mailbox_query[MAX_PAGES]
@@ -172,7 +179,7 @@ module Aspera
           loop do
             # get a batch of package information
             # order: first batch is latest packages, and then in a batch ids are increasing
-            atom_xml = api_v3.call({operation: 'GET', subpath: "#{mailbox}.atom", headers: {'Accept' => 'application/xml'}, url_params: mailbox_query})[:http].body
+            atom_xml = api_v3.call(operation: 'GET', subpath: "#{mailbox}.atom", headers: {'Accept' => 'application/xml'}, url_params: 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)}
             items = box_data.key?('entry') ? box_data['entry'] : []
@@ -232,15 +239,15 @@ module Aspera
           package_create_params[:passcode] = link_data[:query]['passcode']
           delivery_info[:transfer_type] = 'connect'
           delivery_info[:source_paths_list] = transfer.source_list.join("\r\n")
-          api_public_link = Rest.new({base_url: link_data[:base_url]})
+          api_public_link = Rest.new(base_url: link_data[:base_url])
           # Hum, as this does not always work (only user, but not dropbox), we get the javascript and need hack
           # pkg_created=api_public_link.create(create_path,package_create_params)[:data]
           # so extract data from javascript
-          package_creation_data = api_public_link.call({
+          package_creation_data = api_public_link.call(
             operation:   'POST',
             subpath:     create_path,
             json_params: package_create_params,
-            headers:     {'Accept' => 'text/javascript'}})[:http].body
+            headers:     {'Accept' => 'text/javascript'})[:http].body
           # get arguments of function call
           package_creation_data.delete!("\n") # one line
           package_creation_data.gsub!(/^[^"]+\("\{/, '{') # delete header
@@ -283,7 +290,7 @@ module Aspera
               }
             when :send
               delivery_info = options.get_option(:delivery_info, mandatory: true)
-              assert_type(delivery_info, Hash, exception_class: Cli::BadArgument){'delivery_info'}
+              Aspera.assert_type(delivery_info, Hash, exception_class: Cli::BadArgument){'delivery_info'}
               # actual parameter to faspex API
               package_create_params = {'delivery' => delivery_info}
               public_link_url = options.get_option(:link)
@@ -293,17 +300,17 @@ module Aspera
                 first_source = delivery_info['sources'].first
                 first_source['paths'].push(*transfer.source_list)
                 source_id = instance_identifier(as_option: :remote_source) do |field, value|
-                  assert(field.eql?('name'), exception_class: Cli::BadArgument){'only name as selector, or give id'}
-                  source_list = api_v3.call({operation: 'GET', subpath: 'source_shares', headers: {'Accept' => 'application/json'}})[:data]['items']
+                  Aspera.assert(field.eql?('name'), exception_class: Cli::BadArgument){'only name as selector, or give id'}
+                  source_list = api_v3.call(operation: 'GET', subpath: 'source_shares', headers: {'Accept' => 'application/json'})[:data]['items']
                   self.class.get_source_id_by_name(value, source_list)
                 end
                 first_source['id'] = source_id.to_i unless source_id.nil?
-                pkg_created = api_v3.call({
+                pkg_created = api_v3.call(
                   operation:   'POST',
                   subpath:     'send',
                   json_params: package_create_params,
                   headers:     {'Accept' => 'application/json'}
-                })[:data]
+                )[:data]
                 if first_source.key?('id')
                   # no transfer spec if remote source: handled by faspex
                   return {data: [pkg_created['links']['status']], type: :value_list, name: 'link'}
@@ -327,7 +334,7 @@ module Aspera
               when nil # usual case: no link
                 if options.get_option(:once_only, mandatory: true)
                   skip_ids_persistency = PersistencyActionOnce.new(
-                    manager: @agents[:persistency],
+                    manager: persistency,
                     data:    skip_ids_data,
                     id:      IdGenerator.from_list([
                       'faspex_recv',
@@ -343,13 +350,13 @@ module Aspera
                 if delivery_id.eql?(ExtendedValue::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)}}
                 elsif delivery_id.eql?(ExtendedValue::INIT)
-                  assert(skip_ids_persistency){'Only with option once_only'}
+                  Aspera.assert(skip_ids_persistency){'Only with option once_only'}
                   skip_ids_persistency.data.clear.concat(mailbox_filtered_entries.map{|i|{id: i[PACKAGE_MATCH_FIELD]}})
                   skip_ids_persistency.save
                   return Main.result_status("Initialized skip for #{skip_ids_persistency.data.count} package(s)")
                 elsif !recipient.nil? && recipient.start_with?('*')
                   found_package_link = mailbox_filtered_entries(stop_at_id: delivery_id).find{|p|p[PACKAGE_MATCH_FIELD].eql?(delivery_id)}['link'].first['href']
-                  raise "Not Found. Dropbox and Workgroup packages can use the link option with #{Fasp::Uri::SCHEME}" if found_package_link.nil?
+                  raise "Not Found. Dropbox and Workgroup packages can use the link option with #{Transfer::Uri::SCHEME}" if found_package_link.nil?
                   pkg_id_uri = [{id: delivery_id, uri: found_package_link}]
                 else
                   # TODO: delivery id is the right one if package was receive by workgroup
@@ -358,11 +365,11 @@ module Aspera
                     when :inbox, :archive then'received'
                     when :sent then 'sent'
                     end
-                  entry_xml = api_v3.call({operation: 'GET', subpath: "#{endpoint}/#{delivery_id}", headers: {'Accept' => 'application/xml'}})[:http].body
+                  entry_xml = api_v3.call(operation: 'GET', subpath: "#{endpoint}/#{delivery_id}", headers: {'Accept' => 'application/xml'})[:http].body
                   package_entry = XmlSimple.xml_in(entry_xml, {'ForceArray' => true})
                   pkg_id_uri = [{id: delivery_id, uri: self.class.get_fasp_uri_from_entry(package_entry)}]
                 end
-              when /^#{Fasp::Uri::SCHEME}:/o
+              when /^#{Transfer::Uri::SCHEME}:/o
                 pkg_id_uri = [{id: 'package', uri: link_url}]
               else
                 link_data = self.class.get_link_data(link_url)
@@ -370,7 +377,7 @@ module Aspera
                   raise Cli::BadArgument, "Pub link is #{link_data[:subpath]}. Expecting #{PUB_LINK_EXTERNAL_MATCH}"
                 end
                 # NOTE: unauthenticated API (authorization is in url params)
-                api_public_link = Rest.new({base_url: link_data[:base_url]})
+                api_public_link = Rest.new(base_url: link_data[:base_url])
                 package_creation_data = api_public_link.call(
                   operation: 'GET',
                   subpath: link_data[:subpath],
@@ -397,19 +404,19 @@ module Aspera
                   # skip package with no link: empty or content deleted
                   statuses = [:success]
                 else
-                  transfer_spec = Fasp::Uri.new(id_uri[:uri]).transfer_spec
-                  # NOTE: only external users have token in Fasp::Uri::SCHEME link !
+                  transfer_spec = Transfer::Uri.new(id_uri[:uri]).transfer_spec
+                  # NOTE: only external users have token in Transfer::Uri::SCHEME link !
                   if !transfer_spec.key?('token')
                     sanitized = id_uri[:uri].gsub('&', '&amp;')
                     xml_payload =
                       %Q(<?xml version="1.0" encoding="UTF-8"?><url-list xmlns="http://schemas.asperasoft.com/xml/url-list"><url href="#{sanitized}"/></url-list>)
-                    transfer_spec['token'] = api_v3.call({
+                    transfer_spec['token'] = api_v3.call(
                       operation:        'POST',
                       subpath:          'issue-token?direction=down',
                       headers:          {'Accept' => 'text/plain', 'Content-Type' => 'application/vnd.aspera.url-list+xml'},
-                      text_body_params: xml_payload})[:http].body
+                      text_body_params: xml_payload)[:http].body
                   end
-                  transfer_spec['direction'] = Fasp::TransferSpec::DIRECTION_RECEIVE
+                  transfer_spec['direction'] = Transfer::Spec::DIRECTION_RECEIVE
                   statuses = transfer.start(transfer_spec)
                 end
                 result_transfer.push({'package' => id_uri[:id], Main::STATUS_FIELD => statuses})
@@ -421,23 +428,23 @@ module Aspera
             end
           when :source
             command_source = options.get_next_command(%i[list info node])
-            source_list = api_v3.call({operation: 'GET', subpath: 'source_shares', headers: {'Accept' => 'application/json'}})[:data]['items']
+            source_list = api_v3.call(operation: 'GET', subpath: 'source_shares', headers: {'Accept' => 'application/json'})[:data]['items']
             case command_source
             when :list
               return {type: :object_list, data: source_list}
             else # :info :node
               source_id = instance_identifier do |field, value|
-                assert(field.eql?('name'), exception_class: Cli::BadArgument){'only name as selector, or give id'}
+                Aspera.assert(field.eql?('name'), exception_class: Cli::BadArgument){'only name as selector, or give id'}
                 self.class.get_source_id_by_name(value, source_list)
               end.to_i
               source_name = source_list.find{|i|i['id'].eql?(source_id)}['name']
               source_hash = options.get_option(:storage, mandatory: true)
               # check value of option
-              assert_type(source_hash, Hash, exception_class: Cli::Error){'storage option'}
+              Aspera.assert_type(source_hash, Hash, exception_class: Cli::Error){'storage option'}
               source_hash.each do |name, storage|
-                assert_type(storage, Hash, exception_class: Cli::Error){"storage '#{name}'"}
+                Aspera.assert_type(storage, Hash, exception_class: Cli::Error){"storage '#{name}'"}
                 [KEY_NODE, KEY_PATH].each do |key|
-                  assert(storage.key?(key), exception_class: Cli::Error){"storage '#{name}' must have a '#{key}'"}
+                  Aspera.assert(storage.key?(key), exception_class: Cli::Error){"storage '#{name}' must have a '#{key}'"}
                 end
               end
               if !source_hash.key?(source_name)
@@ -451,25 +458,25 @@ module Aspera
               when :node
                 node_config = ExtendedValue.instance.evaluate(source_info[KEY_NODE])
                 Log.log.debug{"node=#{node_config}"}
-                assert_type(node_config, Hash, exception_class: Cli::Error){source_info[KEY_NODE]}
-                api_node = Rest.new({
+                Aspera.assert_type(node_config, Hash, exception_class: 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(@agents, api: api_node).execute_action(command, source_info[KEY_PATH])
+                return Node.new(**init_params, api: api_node).execute_action(command, source_info[KEY_PATH])
               end
             end
           when :me
-            my_info = api_v3.call({operation: 'GET', subpath: 'me', headers: {'Accept' => 'application/json'}})[:data]
+            my_info = api_v3.call(operation: 'GET', subpath: 'me', headers: {'Accept' => 'application/json'})[:data]
             return {data: my_info, type: :single_object}
           when :dropbox
             command_pkg = options.get_next_command([:list])
             case command_pkg
             when :list
-              dropbox_list = api_v3.call({operation: 'GET', subpath: 'dropboxes', headers: {'Accept' => 'application/json'}})[:data]
+              dropbox_list = api_v3.call(operation: 'GET', subpath: 'dropboxes', headers: {'Accept' => 'application/json'})[:data]
               return {type: :object_list, data: dropbox_list['items'], fields: %w[name id description can_read can_write]}
             end
           when :v4
@@ -516,7 +523,7 @@ module Aspera
             end
             return {type: :object_list, data: users}
           when :login_methods
-            login_meths = api_v3.call({operation: 'GET', subpath: 'login/new', headers: {'Accept' => 'application/xrds+xml'}})[:http].body
+            login_meths = api_v3.call(operation: 'GET', subpath: 'login/new', headers: {'Accept' => 'application/xrds+xml'})[:http].body
             login_methods = XmlSimple.xml_in(login_meths, {'ForceArray' => false})
             return {type: :object_list, data: login_methods['XRD']['Service']}
           end # command