aspera-cli 4.3.0 → 4.4.0

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

@@ -45,6 +45,7 @@ module Aspera
         AOC_COMMAND_V2='aspera'
         AOC_COMMAND_V3='aoc'
         AOC_COMMAND_CURRENT=AOC_COMMAND_V3
+        SERVER_COMMAND='server'
         CONNECT_WEB_URL = 'https://d3gcli72yxqn2z.cloudfront.net/connect'
         CONNECT_VERSIONS = 'connectversions.js'
         TRANSFER_SDK_ARCHIVE_URL = 'https://ibm.biz/aspera_sdk'
@@ -58,14 +59,31 @@ Subject: Amelia email test
 
 It worked !
 END_OF_TEMPLATE
+        # special extended values
+        EXTV_INCLUDE_PRESETS='incps'
+        EXTV_PRESET='preset'
+        DEFAULT_CHECK_NEW_VERSION_DAYS=7
+        DEFAULT_PRIV_KEY_FILENAME='aspera_aoc_key'
+        DEFAULT_PRIVKEY_LENGTH=4096
+        private_constant :DEFAULT_CONFIG_FILENAME,:CONF_PRESET_CONFIG,:CONF_PRESET_VERSION,:CONF_PRESET_DEFAULT,
+        :CONF_PRESET_GLOBAL,:PROGRAM_NAME_V1,:PROGRAM_NAME_V2,:DEFAULT_REDIRECT,:ASPERA_PLUGINS_FOLDERNAME,
+        :RUBY_FILE_EXT,:AOC_COMMAND_V1,:AOC_COMMAND_V2,:AOC_COMMAND_V3,:AOC_COMMAND_CURRENT,:DEMO,
+        :TRANSFER_SDK_ARCHIVE_URL,:AOC_PATH_API_CLIENTS,:DEMO_SERVER_PRESET,:EMAIL_TEST_TEMPLATE,:EXTV_INCLUDE_PRESETS,
+        :EXTV_PRESET,:DEFAULT_CHECK_NEW_VERSION_DAYS,:DEFAULT_PRIV_KEY_FILENAME,:SERVER_COMMAND
         def option_preset; nil; end
 
         def option_preset=(value)
-          self.options.add_option_preset(preset_by_name(value))
+          case value
+          when String
+            self.options.add_option_preset(preset_by_name(value))
+          when Hash
+            self.options.add_option_preset(value)
+          else
+            raise "Preset definition must be a String for name, or Hash for value"
+          end
+          nil
         end
 
-        private_constant :DEFAULT_CONFIG_FILENAME,:CONF_PRESET_CONFIG,:CONF_PRESET_VERSION,:CONF_PRESET_DEFAULT,:CONF_PRESET_GLOBAL,:PROGRAM_NAME_V1,:PROGRAM_NAME_V2,:DEFAULT_REDIRECT,:ASPERA_PLUGINS_FOLDERNAME,:RUBY_FILE_EXT,:AOC_COMMAND_V1,:AOC_COMMAND_V2,:AOC_COMMAND_V3,:AOC_COMMAND_CURRENT,:DEMO,:TRANSFER_SDK_ARCHIVE_URL,:AOC_PATH_API_CLIENTS,:DEMO_SERVER_PRESET,:EMAIL_TEST_TEMPLATE
-
         def initialize(env,tool_name,help_url,version,main_folder)
           super(env)
           raise 'missing secret manager' if @agents[:secret].nil?
@@ -93,35 +111,36 @@ END_OF_TEMPLATE
           # add preset handler (needed for smtp)
           ExtendedValue.instance.set_handler(EXTV_PRESET,:reader,lambda{|v|preset_by_name(v)})
           ExtendedValue.instance.set_handler(EXTV_INCLUDE_PRESETS,:decoder,lambda{|v|expanded_with_preset_includes(v)})
-          self.options.set_obj_attr(:override,self,:option_override,:no)
           self.options.set_obj_attr(:ascp_path,self,:option_ascp_path)
           self.options.set_obj_attr(:use_product,self,:option_use_product)
           self.options.set_obj_attr(:preset,self,:option_preset)
           self.options.set_obj_attr(:secret,@agents[:secret],:default_secret)
           self.options.set_obj_attr(:secrets,@agents[:secret],:all_secrets)
-          self.options.add_opt_boolean(:override,'override existing value')
           self.options.add_opt_switch(:no_default,'-N','do not load default configuration for plugin') { @use_plugin_defaults=false }
-          self.options.add_opt_boolean(:use_generic_client,'wizard: AoC: use global or org specific jwt client id')
-          self.options.add_opt_simple(:pkeypath,'path to private key for JWT (wizard)')
+          self.options.add_opt_boolean(:override,'Wizard: override existing value')
+          self.options.add_opt_boolean(:use_generic_client,'Wizard: AoC: use global or org specific jwt client id')
+          self.options.add_opt_boolean(:default,'Wizard: set as default configuration for specified plugin (also: update)')
+          self.options.add_opt_boolean(:test_mode,'Wizard: skip private key check step')
+          self.options.add_opt_simple(:pkeypath,'Wizard: path to private key for JWT')
           self.options.add_opt_simple(:ascp_path,'path to ascp')
           self.options.add_opt_simple(:use_product,'use ascp from specified product')
           self.options.add_opt_simple(:smtp,'smtp configuration (extended value: hash)')
           self.options.add_opt_simple(:fpac,'proxy auto configuration URL')
           self.options.add_opt_simple(:preset,'-PVALUE','load the named option preset from current config file')
-          self.options.add_opt_simple(:default,'set as default configuration for specified plugin')
           self.options.add_opt_simple(:secret,'default secret')
           self.options.add_opt_simple(:secrets,'secret repository (Hash)')
           self.options.add_opt_simple(:sdk_url,'URL to get SDK')
-          self.options.add_opt_simple(:sdk_folder,'SDK folder location')
+          self.options.add_opt_simple(:sdk_folder,'SDK folder path')
           self.options.add_opt_simple(:notif_to,'email recipient for notification of transfers')
           self.options.add_opt_simple(:notif_template,'email ERB template for notification of transfers')
-          self.options.add_opt_boolean(:test_mode,'skip user validation in wizard mode')
-          self.options.add_opt_simple(:version_check_days,Integer,'period to check neew version in days (zero to disable)')
+          self.options.add_opt_simple(:version_check_days,Integer,'period in days to check new version (zero to disable)')
           self.options.set_option(:use_generic_client,true)
           self.options.set_option(:test_mode,false)
-          self.options.set_option(:version_check_days,7)
+          self.options.set_option(:default,true)
+          self.options.set_option(:version_check_days,DEFAULT_CHECK_NEW_VERSION_DAYS)
           self.options.set_option(:sdk_url,TRANSFER_SDK_ARCHIVE_URL)
           self.options.set_option(:sdk_folder,File.join(@main_folder,'sdk'))
+          self.options.set_option(:override,:no)
           self.options.parse_options!
           raise CliBadArgument,'secrets shall be Hash' unless @agents[:secret].all_secrets.is_a?(Hash)
           Fasp::Installation.instance.folder=self.options.get_option(:sdk_folder,:mandatory)
@@ -198,9 +217,9 @@ END_OF_TEMPLATE
         end
         private
 
-        def generate_new_key(private_key_path)
+        def generate_rsa_private_key(private_key_path,length)
           require 'openssl'
-          priv_key = OpenSSL::PKey::RSA.new(4096)
+          priv_key = OpenSSL::PKey::RSA.new(length)
           File.write(private_key_path,priv_key.to_s)
           File.write(private_key_path+'.pub',priv_key.public_key.to_s)
           nil
@@ -253,12 +272,8 @@ END_OF_TEMPLATE
         attr_reader :main_folder
         attr_reader :gem_url
         attr_reader :plugins
-        attr_accessor :option_override
         attr_accessor :option_config_file
 
-        EXTV_INCLUDE_PRESETS='incps'
-        EXTV_PRESET='preset'
-
         # @return the hash from name (also expands possible includes)
         def preset_by_name(config_name, include_path=[])
           raise CliError,"no such config preset: #{config_name}" unless @config_presets.has_key?(config_name)
@@ -343,11 +358,11 @@ END_OF_TEMPLATE
               Log.log.warn("No config file found. Creating empty configuration file: #{@option_config_file}")
               @config_presets={CONF_PRESET_CONFIG=>{CONF_PRESET_VERSION=>@program_version}}
             else
-              Log.log.debug "loading #{@option_config_file}"
+              Log.log.debug("loading #{@option_config_file}")
               @config_presets=YAML.load_file(conf_file_to_load)
             end
             files_to_copy=[]
-            Log.log.debug "Available_presets: #{@config_presets}"
+            Log.log.debug("Available_presets: #{@config_presets}")
             raise 'Expecting YAML Hash' unless @config_presets.is_a?(Hash)
             # check there is at least the config section
             if !@config_presets.has_key?(CONF_PRESET_CONFIG)
@@ -589,7 +604,7 @@ END_OF_TEMPLATE
               save_presets_to_config_file
               return Main.result_status("Modified: #{@option_config_file}")
             when :update
-              default_for_plugin=self.options.get_option(:default,:optional)
+              default_for_plugin=self.options.get_option(:default,:mandatory)
               #  get unprocessed options
               theopts=self.options.get_options_table
               Log.log.debug("opts=#{theopts}")
@@ -621,7 +636,7 @@ END_OF_TEMPLATE
             return Main.result_nothing
           when :genkey # generate new rsa key
             private_key_path=self.options.get_next_argument('private key file path')
-            generate_new_key(private_key_path)
+            generate_rsa_private_key(private_key_path,DEFAULT_PRIVKEY_LENGTH)
             return Main.result_status('Generated key: '+private_key_path)
           when :echo # display the content of a value given on command line
             result={:type=>:other_struct, :data=>self.options.get_next_argument('value')}
@@ -638,23 +653,32 @@ END_OF_TEMPLATE
           when :overview
             return {:type=>:object_list,:data=>self.class.flatten_all_config(@config_presets)}
           when :wizard
+            # interactive mode
             self.options.ask_missing_mandatory=true
             # register url option
             BasicAuthPlugin.new(@agents.merge(skip_option_header: true))
+            # get from option, or ask
             instance_url=self.options.get_option(:url,:mandatory)
+            # allow user to tell the preset name
+            preset_name=self.options.get_option(:id,:optional)
             appli=ApiDetector.discover_product(instance_url)
+            plugin_name="<replace per app>"
+            test_args="<replace per app>"
             case appli[:product]
             when :aoc
               self.format.display_status('Detected: Aspera on Cloud'.bold)
+              plugin_name=AOC_COMMAND_CURRENT
               organization,instance_domain=AoC.parse_url(instance_url)
-              aspera_preset_name='aoc_'+organization
-              self.format.display_status("Preparing preset: #{aspera_preset_name}")
+              # if not defined by user, generate name
+              preset_name=[appli[:product],organization].join('_') if preset_name.nil?
+              self.format.display_status("Preparing preset: #{preset_name}")
               # init defaults if necessary
-              @config_presets[CONF_PRESET_DEFAULT]||=Hash.new
-              if !option_override
-                raise CliError,"a default configuration already exists for plugin '#{AOC_COMMAND_CURRENT}' (use --override=yes)" if @config_presets[CONF_PRESET_DEFAULT].has_key?(AOC_COMMAND_CURRENT)
-                raise CliError,"preset already exists: #{aspera_preset_name}  (use --override=yes)" if @config_presets.has_key?(aspera_preset_name)
-              end
+              @config_presets[CONF_PRESET_DEFAULT]||={}
+              option_override=self.options.get_option(:override,:mandatory)
+              option_default=self.options.get_option(:default,:mandatory)
+              Log.log.error("override=#{option_override} -> #{option_override.class}")
+              raise CliError,"A default configuration already exists for plugin '#{plugin_name}' (use --override=yes or --default=no)" if !option_override and option_default and @config_presets[CONF_PRESET_DEFAULT].has_key?(plugin_name)
+              raise CliError,"Preset already exists: #{preset_name}  (use --override=yes or --id=<name>)" if !option_override and @config_presets.has_key?(preset_name)
               # lets see if path to priv key is provided
               private_key_path=self.options.get_option(:pkeypath,:optional)
               # give a chance to provide
@@ -664,23 +688,23 @@ END_OF_TEMPLATE
               end
               # else generate path
               if private_key_path.empty?
-                private_key_path=File.join(@main_folder,'aspera_aoc_key')
+                private_key_path=File.join(@main_folder,DEFAULT_PRIV_KEY_FILENAME)
               end
               if File.exist?(private_key_path)
                 self.format.display_status('Using existing key:')
               else
-                self.format.display_status('Generating key...')
-                generate_new_key(private_key_path)
+                self.format.display_status("Generating #{DEFAULT_PRIVKEY_LENGTH} bit RSA key...")
+                generate_rsa_private_key(private_key_path,DEFAULT_PRIVKEY_LENGTH)
                 self.format.display_status('Created:')
               end
-              self.format.display_status("#{private_key_path}")
+              self.format.display_status(private_key_path)
               pub_key_pem=OpenSSL::PKey::RSA.new(File.read(private_key_path)).public_key.to_s
               # declare command line options for AoC
               require 'aspera/cli/plugins/aoc'
               # make username mandatory for jwt, this triggers interactive input
               self.options.get_option(:username,:mandatory)
               # instanciate AoC plugin, so that command line options are known
-              files_plugin=self.class.plugin_new(AOC_COMMAND_CURRENT,@agents.merge({skip_basic_auth_options: true, private_key_path: private_key_path}))
+              files_plugin=self.class.plugin_new(plugin_name,@agents.merge({skip_basic_auth_options: true, private_key_path: private_key_path}))
               aoc_api=files_plugin.get_api
               auto_set_pub_key=false
               auto_set_jwt=false
@@ -723,7 +747,7 @@ END_OF_TEMPLATE
               end
               myself=aoc_api.read('self')[:data]
               if auto_set_pub_key
-                raise CliError,'public key is already set in profile (use --override=yes)'  unless myself['public_key'].empty? or option_override
+                raise CliError,'Public key is already set in profile (use --override=yes)'  unless myself['public_key'].empty? or option_override
                 self.format.display_status('Updating profile with new key')
                 aoc_api.update("users/#{myself['id']}",{'public_key'=>pub_key_pem})
               end
@@ -731,8 +755,8 @@ END_OF_TEMPLATE
                 self.format.display_status('Enabling JWT for client')
                 aoc_api.update("clients/#{self.options.get_option(:client_id)}",{'jwt_grant_enabled'=>true,'explicit_authorization_required'=>false})
               end
-              self.format.display_status("creating new config preset: #{aspera_preset_name}")
-              @config_presets[aspera_preset_name]={
+              self.format.display_status("Creating new config preset: #{preset_name}")
+              @config_presets[preset_name]={
                 :url.to_s           =>self.options.get_option(:url),
                 :username.to_s      =>myself['email'],
                 :auth.to_s          =>:jwt.to_s,
@@ -741,16 +765,21 @@ END_OF_TEMPLATE
               # set only if non nil
               [:client_id,:client_secret].each do |s|
                 o=self.options.get_option(s)
-                @config_presets[s.to_s] = o unless o.nil?
+                @config_presets[preset_name][s.to_s] = o unless o.nil?
               end
-              self.format.display_status("Setting config preset as default for #{AOC_COMMAND_CURRENT}")
-              @config_presets[CONF_PRESET_DEFAULT][AOC_COMMAND_CURRENT]=aspera_preset_name
-              self.format.display_status('saving config file')
-              save_presets_to_config_file
-              return Main.result_status("Done.\nYou can test with:\n#{@tool_name} #{AOC_COMMAND_CURRENT} user info show")
+              test_args="#{plugin_name} user info show"
             else
               raise CliBadArgument,"Supports only: aoc. Detected: #{appli}"
+            end # product
+            if option_default
+              self.format.display_status("Setting config preset as default for #{plugin_name}")
+              @config_presets[CONF_PRESET_DEFAULT][plugin_name]=preset_name
+            else
+              test_args="-P#{preset_name} #{test_args}"
             end
+            self.format.display_status('Saving config file.')
+            save_presets_to_config_file
+            return Main.result_status("Done.\nYou can test with:\n#{@tool_name} #{test_args}")
           when :export_to_cli
             self.format.display_status('Exporting: Aspera on Cloud')
             require 'aspera/cli/plugins/aoc'
@@ -820,16 +849,16 @@ END_OF_TEMPLATE
               @config_presets[DEMO_SERVER_PRESET]={'url'=>'ssh://'+DEMO+'.asperasoft.com:33001','username'=>AOC_COMMAND_V2,'ssAP'.downcase.reverse+'drow'.reverse=>DEMO+AOC_COMMAND_V2}
             end
             @config_presets[CONF_PRESET_DEFAULT]||={}
-            if @config_presets[CONF_PRESET_DEFAULT].has_key?('server')
-              Log.log.warn("server default preset already set to: #{@config_presets[CONF_PRESET_DEFAULT]['server']}")
-              Log.log.warn("use #{DEMO_SERVER_PRESET} for demo: -P#{DEMO_SERVER_PRESET}") unless DEMO_SERVER_PRESET.eql?(@config_presets[CONF_PRESET_DEFAULT]['server'])
+            if @config_presets[CONF_PRESET_DEFAULT].has_key?(SERVER_COMMAND)
+              Log.log.warn("Server default preset already set to: #{@config_presets[CONF_PRESET_DEFAULT][SERVER_COMMAND]}")
+              Log.log.warn("Use #{DEMO_SERVER_PRESET} for demo: -P#{DEMO_SERVER_PRESET}") unless DEMO_SERVER_PRESET.eql?(@config_presets[CONF_PRESET_DEFAULT][SERVER_COMMAND])
             else
-              @config_presets[CONF_PRESET_DEFAULT]['server']=DEMO_SERVER_PRESET
-              Log.log.info("setting server default preset to : #{DEMO_SERVER_PRESET}")
+              @config_presets[CONF_PRESET_DEFAULT][SERVER_COMMAND]=DEMO_SERVER_PRESET
+              Log.log.info("Setting server default preset to : #{DEMO_SERVER_PRESET}")
             end
             save_presets_to_config_file
             return Main.result_status("Done")
-          else raise 'error'
+          else raise 'INTERNAL ERROR: wrong case'
           end
         end
 
@@ -888,7 +917,7 @@ END_OF_TEMPLATE
         def save_presets_to_config_file
           raise 'no configuration loaded' if @config_presets.nil?
           FileUtils.mkdir_p(@main_folder) unless Dir.exist?(@main_folder)
-          Log.log.debug "writing #{@option_config_file}"
+          Log.log.debug("Writing #{@option_config_file}")
           File.write(@option_config_file,@config_presets.to_yaml)
         end
 

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

@@ -23,12 +23,14 @@ module Aspera
         PACKAGE_MATCH_FIELD='package_id'
         # list of supported atoms
         ATOM_MAILBOXES=[:inbox, :archive, :sent]
-        # number is added by CLI
-        MAX_ITEMS='max'
-        MAX_PAGES='pmax'
-        ATOM_PARAMS=['page', 'count', 'startIndex', MAX_ITEMS, MAX_PAGES]
+        # allowed parameters for inbox.atom
+        ATOM_PARAMS=['page', 'count', 'startIndex']
+        # with special parameters (from Plugin class)
+        ATOM_EXT_PARAMS=ATOM_PARAMS+[MAX_ITEMS, MAX_PAGES]
+        # sub path in url for public link delivery
         PUB_LINK_EXTERNAL_MATCH='external_deliveries/'
-        private_constant :KEY_NODE,:KEY_PATH,:VAL_ALL,:PACKAGE_MATCH_FIELD,:ATOM_MAILBOXES,:PUB_LINK_EXTERNAL_MATCH
+        private_constant :KEY_NODE,:KEY_PATH,:VAL_ALL,:PACKAGE_MATCH_FIELD,:ATOM_MAILBOXES,
+        :ATOM_PARAMS,:ATOM_EXT_PARAMS,:PUB_LINK_EXTERNAL_MATCH
 
         def initialize(env)
           @api_v3=nil
@@ -126,7 +128,7 @@ module Aspera
           result=[]
           if !mailbox_query.nil?
             raise "query: must be Hash or nil" unless mailbox_query.is_a?(Hash)
-            raise "query: supported params: #{ATOM_PARAMS}" unless (mailbox_query.keys-ATOM_PARAMS).empty?
+            raise "query: supported params: #{ATOM_EXT_PARAMS}" unless (mailbox_query.keys-ATOM_EXT_PARAMS).empty?
             raise "query: startIndex and page are exclusive" if mailbox_query.has_key?('startIndex') and mailbox_query.has_key?('page')
             max_items=mailbox_query[MAX_ITEMS]
             mailbox_query.delete(MAX_ITEMS)

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

@@ -13,22 +13,34 @@ module Aspera
         private_constant :SAMPLE_SOAP_CALL
         def initialize(env)
           super(env)
-          # this is added to some requests , for instance to add tags
+          # this is added to some requests , for instance to add tags (COS)
           @add_request_param = env[:add_request_param] || {}
           unless env[:skip_basic_auth_options]
             self.options.add_opt_simple(:validator,"identifier of validator (optional for central)")
             self.options.add_opt_simple(:asperabrowserurl,"URL for simple aspera web ui")
             self.options.add_opt_simple(:name,"sync name")
-            self.options.add_opt_list(:token,[:aspera,:basic,:auto],'todo: type of token used for transfers')
+            self.options.add_opt_list(:token_type,[:aspera,:basic,:hybrid],'Type of token used for transfers')
             self.options.set_option(:asperabrowserurl,'https://asperabrowser.mybluemix.net')
-            self.options.set_option(:token,:aspera)
+            self.options.set_option(:token_type,:aspera)
             self.options.parse_options!
           end
           return if env[:man_only]
           if env.has_key?(:node_api)
             @api_node=env[:node_api]
           else
-            @api_node=basic_auth_api unless env[:man_only]
+            if self.options.get_option(:password,:mandatory).start_with?('Bearer ')
+              # info is provided like node_info of aoc
+              @api_node=Rest.new({
+                base_url: self.options.get_option(:url,:mandatory),
+                headers: {
+                'Authorization'      => self.options.get_option(:password,:mandatory),
+                'X-Aspera-AccessKey' => self.options.get_option(:username,:mandatory),
+                }
+              })
+            else
+              # this is normal case
+              @api_node=basic_auth_api
+            end
           end
         end
 
@@ -191,22 +203,36 @@ module Aspera
               #raise "unknown type: #{send_result['self']['type']}"
             end
             return c_result_remove_prefix_path(result,'path',prefix_path)
-          when :upload
-            # we send only a list of one transfer request
-            transfer_request = { :paths => [ { :destination => self.transfer.destination_folder('send') } ] }
-            transfer_request.deep_merge!(@add_request_param)
-            send_result=@api_node.create('files/upload_setup',{:transfer_requests => [ { :transfer_request => transfer_request } ] } )[:data]
-            # only one request, so only one answer
-            transfer_spec=send_result['transfer_specs'].first['transfer_spec']
-            # delete this part, as the returned value contains only destination, and not sources
-            transfer_spec.delete('paths')
-            return Main.result_transfer(self.transfer.start(transfer_spec,{:src=>:node_gen3}))
-          when :download
-            transfer_request = {:paths => self.transfer.ts_source_paths }
-            transfer_request.deep_merge!(@add_request_param)
-            send_result=@api_node.create('files/download_setup',{:transfer_requests => [ { :transfer_request => transfer_request } ] } )[:data]
-            # only one request, so only one answer
-            transfer_spec=send_result['transfer_specs'].first['transfer_spec']
+          when :upload,:download
+            token_type=self.options.get_option(:token_type,:optional)
+            # nil if Shares 1.x
+            token_type=:aspera if token_type.nil?
+            case token_type
+            when :aspera,:hybrid
+              transfer_paths=case command
+              when :upload;[ { :destination => self.transfer.destination_folder('send') } ]
+              when :download;self.transfer.ts_source_paths
+              end
+              # only one request, so only one answer
+              transfer_spec=@api_node.create("files/#{command}_setup",{:transfer_requests => [ { transfer_request: {
+                paths: transfer_paths
+                }.deep_merge(@add_request_param) } ] } )[:data]['transfer_specs'].first['transfer_spec']
+              # delete this part, as the returned value contains only destination, and not sources
+              transfer_spec.delete('paths') if command.eql?(:upload)
+            when :basic
+              raise "shall have auth" unless @api_node.params[:auth].is_a?(Hash)
+              raise "shall be basic auth" unless @api_node.params[:auth][:type].eql?(:basic)
+              transfer_spec={
+                'remote_host'=>URI.parse(@api_node.params[:base_url]).host,
+                'remote_user'=>Aspera::Node::ACCESS_KEY_TRANSFER_USER,
+                'ssh_port'=>Aspera::Node::SSH_PORT_DEFAULT,
+                'direction'=>case command;when :upload;'send';when :download;'recv';else raise "Error";end
+              }
+            else raise "ERROR: token_type #{tt}"
+            end
+            if [:basic,:hybrid].include?(token_type)
+              Aspera::Node.set_ak_basic_token(transfer_spec,@api_node.params[:auth][:username],@api_node.params[:auth][:password])
+            end
             return Main.result_transfer(self.transfer.start(transfer_spec,{:src=>:node_gen3}))
           when :api_details
             return { :type=>:single_object, :data => @api_node.params }
@@ -409,9 +435,11 @@ module Aspera
               command=self.options.get_next_command([ :list, :modify])
               case command
               when :list
-                request_data.deep_merge!({"validation"=>validation}) unless validation.nil?
-                resp=@api_node.create('services/rest/transfers/v1/files',request_data)
-                return {:type=>:object_list,:data=>resp[:data]["file_transfer_info_result"]["file_transfer_info"],:fields=>["session_uuid","file_id","status","path"]}
+                request_data.deep_merge!({'validation'=>validation}) unless validation.nil?
+                resp=@api_node.create('services/rest/transfers/v1/files',request_data)[:data]
+                resp=JSON.parse(resp) if resp.is_a?(String)
+                Log.dump(:resp,resp)
+                return {:type=>:object_list,:data=>resp['file_transfer_info_result']['file_transfer_info'],:fields=>["session_uuid","file_id","status","path"]}
               when :modify
                 request_data.deep_merge!(validation) unless validation.nil?
                 @api_node.update('services/rest/transfers/v1/files',request_data)

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

@@ -202,15 +202,17 @@ module Aspera
           if @default_transfer_spec.nil?
             # make a dummy call to get some default transfer parameters
             res=@api_node.create('files/upload_setup',{'transfer_requests'=>[{'transfer_request'=>{'paths'=>[{}],'destination_root'=>'/'}}]})
-            sample_transfer_spec=res[:data]['transfer_specs'].first['transfer_spec']
+            template_ts=res[:data]['transfer_specs'].first['transfer_spec']
             # get ports, anyway that should be 33001 for both. add remote_user ?
-            @default_transfer_spec=['ssh_port','fasp_port'].inject({}){|h,e|h[e]=sample_transfer_spec[e];h}
+            @default_transfer_spec=['ssh_port','fasp_port'].inject({}){|h,e|h[e]=template_ts[e];h}
+            if ! @default_transfer_spec['remote_user'].eql?(Aspera::Node::ACCESS_KEY_TRANSFER_USER)
+              Log.log.warn("remote_user shall be xfer")
+              @default_transfer_spec['remote_user']=Aspera::Node::ACCESS_KEY_TRANSFER_USER
+            end
+            Aspera::Node::set_ak_basic_token(@default_transfer_spec,@access_key_self['id'],self.options.get_option(:password,:mandatory))
             # note: we use the same address for ascp than for node api instead of the one from upload_setup
-            @default_transfer_spec.merge!({
-              'token'            => "Basic #{Base64.strict_encode64("#{@access_key_self['id']}:#{self.options.get_option(:password,:mandatory)}")}",
-              'remote_host'      => @transfer_server_address,
-              'remote_user'      => Fasp::ACCESS_KEY_TRANSFER_USER
-            })
+            # TODO: configurable ? useful ?
+            @default_transfer_spec['remote_host']=@transfer_server_address
           end
           tspec=@default_transfer_spec.merge({
             'direction'  => direction,

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

@@ -1,5 +1,6 @@
 require 'aspera/cli/basic_auth_plugin'
 require 'aspera/ascmd'
+require 'aspera/node'
 require 'aspera/ssh'
 require 'aspera/nagios'
 require 'tempfile'
@@ -67,13 +68,15 @@ module Aspera
         def execute_action
           server_uri=URI.parse(self.options.get_option(:url,:mandatory))
           Log.log.debug("URI : #{server_uri}, port=#{server_uri.port}, scheme:#{server_uri.scheme}")
+          server_transfer_spec={'remote_host'=>server_uri.hostname}
           shell_executor=nil
           case server_uri.scheme
           when 'ssh'
-            server_transfer_spec={
-              'remote_host'=>server_uri.hostname,
-              'remote_user'=>self.options.get_option(:username,:mandatory),
-            }
+            if self.options.get_option(:username,:optional).nil?
+              self.options.set_option(:username,Aspera::Node::ACCESS_KEY_TRANSFER_USER)
+              Log.log.info("Using default transfer user: #{Aspera::Node::ACCESS_KEY_TRANSFER_USER}")
+            end
+            server_transfer_spec['remote_user']=self.options.get_option(:username,:mandatory)
             ssh_options=self.options.get_option(:ssh_options,:optional)
             raise 'expecting a Hash for ssh_options' unless ssh_options.is_a?(Hash)
             if !server_uri.port.nil?
@@ -102,8 +105,16 @@ module Aspera
                 cred_set=true
               end
             end
-            raise 'either password or key must be provided' if !cred_set
+            # if user provided transfer spec has a token, we will use by pass keys
+            cred_set=true if self.transfer.option_transfer_spec['token'].is_a?(String)
+            raise 'either password, key , or transfer spec token must be provided' if !cred_set
             shell_executor=Ssh.new(server_transfer_spec['remote_host'],server_transfer_spec['remote_user'],ssh_options)
+          when 'https'
+            raise "ERROR: transfer spec with token required" unless self.transfer.option_transfer_spec['token'].is_a?(String)
+            server_transfer_spec.merge!({
+              'wss_enabled'=>true,
+              'wss_port'   =>server_uri.port
+            })
           when 'local'
             shell_executor=LocalExecutor.new
           else

data/lib/aspera/cli/transfer_agent.rb

@@ -1,7 +1,7 @@
 require 'aspera/fasp/local'
+require 'aspera/fasp/parameters'
 require 'aspera/fasp/connect'
 require 'aspera/fasp/node'
-require 'aspera/fasp/aoc'
 require 'aspera/fasp/http_gw'
 require 'aspera/cli/listener/logger'
 require 'aspera/cli/listener/progress_multi'
@@ -43,9 +43,9 @@ END_OF_TEMPLATE
         options.add_opt_simple(:local_resume,"set resume policy (Hash, use @json: prefix), current=#{options.get_option(:local_resume,:optional)}")
         options.add_opt_simple(:to_folder,"destination folder for downloaded files")
         options.add_opt_simple(:sources,"list of source files (see doc)")
-        options.add_opt_simple(:transfer_info,"additional information for transfer client")
+        options.add_opt_simple(:transfer_info,"parameters for transfer agent")
         options.add_opt_list(:src_type,[:list,:pair],"type of file list")
-        options.add_opt_list(:transfer,[:direct,:httpgw,:connect,:node,:aoc],"type of transfer")
+        options.add_opt_list(:transfer,[:direct,:httpgw,:connect,:node],"type of transfer agent")
         options.add_opt_list(:progress,[:none,:native,:multi],"type of progress bar")
         options.set_option(:transfer,:direct)
         options.set_option(:src_type,:list)
@@ -124,22 +124,6 @@ END_OF_TEMPLATE
           new_agent=Fasp::Node.new(node_api)
           # add root id if it's an access key
           new_agent.options={root_id: node_config[:root_id]} if node_config.has_key?(:root_id)
-        when :aoc
-          aoc_config=options.get_option(:transfer_info,:optional)
-          if aoc_config.nil?
-            param_set_name=config.get_plugin_default_config_name(:aspera)
-            raise CliBadArgument,"No default AoC configured, Please specify --#{:transfer_info.to_s.gsub('_','-')}" if param_set_name.nil?
-            aoc_config=config.preset_by_name(param_set_name)
-          end
-          Log.log.debug("aoc=#{aoc_config}")
-          raise CliBadArgument,"the aoc configuration shall be Hash, not #{aoc_config.class} (#{aoc_config}), refer to manual" if !aoc_config.is_a?(Hash)
-          # convert keys from string (config) to symbol (agent)
-          aoc_config=aoc_config.symbolize_keys
-          # convert auth value from string (config) to symbol (agent)
-          aoc_config[:auth]=aoc_config[:auth].to_sym if aoc_config[:auth].is_a?(String)
-          # private key could be @file:... in config
-          aoc_config[:private_key]=ExtendedValue.instance.evaluate(aoc_config[:private_key])
-          new_agent=Fasp::Aoc.new(aoc_config)
         else
           raise "Unexpected transfer agent type: #{agent_type}"
         end
@@ -183,7 +167,8 @@ END_OF_TEMPLATE
           raise CliBadArgument,"specify at least one file on command line or use --sources=#{FILE_LIST_FROM_TRANSFER_SPEC} to use transfer spec" if !file_list.is_a?(Array) or file_list.empty?
         when FILE_LIST_FROM_TRANSFER_SPEC
           Log.log.debug("assume list provided in transfer spec")
-          raise CliBadArgument,"transfer spec on command line must have sources" if @transfer_paths.nil?
+          special_case_direct_with_list=options.get_option(:transfer,:mandatory).eql?(:direct) and Fasp::Parameters.ts_has_file_list(@transfer_spec_cmdline)
+          raise CliBadArgument,"transfer spec on command line must have sources" if @transfer_paths.nil? and !special_case_direct_with_list
           # here we assume check of sources is made in transfer agent
           return @transfer_paths
         when Array

data/lib/aspera/cli/version.rb

@@ -1,5 +1,5 @@
 module Aspera
   module Cli
-    VERSION = "4.3.0"
+    VERSION = "4.4.0"
   end
 end